exampracticeonline.com
OOPs Concept

Main OOPS concepts are:

  1. Abstraction
  2. Encapsulation
  3. Polymorphism
  4. Inheritance
  5. Association
  6. Aggregation
  7. Composition

Abstraction

Abstraction is the concept of hiding the internal details and describing only the functionalities. For example, a method that adds two integers. The method internal processing is hidden from outer world. There are many ways to achieve abstraction in object oriented programming, such as encapsulation and inheritance.

A java program is also a good example of abstraction. Here java takes care of converting simple statements to machine language and hides the inner implementation details from outer world.

Encapsulation

Encapsulation is a mechanism of wrapping the data (variables) and code acting on the data (methods) together as a single unit.

Encapsulation is the technique used to implement abstraction in object oriented programming.Encapsulation is used for access restriction to a class members and methods. Access modifier keywords are used for encapsulation in object oriented programming. For example, encapsulation in java is achieved using private, protected and public keywords.

Polymorphism

Polymorphism is the concept where an object behaves differently in different situations. There are two types of polymorphism – compile time polymorphism and runtime polymorphism.

Compile time polymorphism is achieved by method overloading. For example, we can have a class as below.

public class SampleCircle {

	public void draw(){
		System.out.println("Drawing circle with default color Black and diameter 1 cm.");
	}
	
	public void draw(int diameter){
		System.out.println("Drawing circle with default color Black and diameter"+diameter+" cm.");
	}
	
	public void draw(int diameter, String color){
		System.out.println("Drawing circle with color"+color+" and diameter"+diameter+" cm.");
	}
}

In this example we have multiple draw methods but they have different behavior. This is a case of method overloading because all the methods name is same and arguments are different. Here compiler will be able to identify the method to invoke at compile time, hence it’s called compile time polymorphism.

 

Runtime polymorphism is implemented when we have “IS-A” relationship between objects. This is also called as method overriding because subclass has to override the superclass method for runtime polymorphism. If we are working in terms of superclass, the actual implementation class is decided at runtime. Compiler is not able to decide which class method will be invoked. This decision is done at runtime, hence the name as runtime polymorphism or dynamic method dispatch.


package com.examplepractice.Sample;

public interface SampleShape {

	public void draw();
}

com.examplepractice.Sample;  

public class SampleCircle implements SampleShape{

	@Override
	public void draw(){
		System.out.println("Drwaing circle");
	}

}

com.examplepractice.Sample;  

public class SampleSquare implements SampleShape {

	@Override
	public void draw() {
		System.out.println("Drawing Square");
	}

}

SampleShape is the superclass and there are two subclasses SampleCircle and SampleSquare. Below is an example of runtime polymorphism.

SampleShape sample_sh = new SampleCircle(); sample sh.draw(); SampleShape sample_sh1 = getShape(); //some third party logic to determine Sampleshape sample_sh1.draw();

In above examples, java compiler don’t know the actual implementation class of Shape that will be used at runtime, hence runtime polymorphism.

Inheritance

Inheritance is the object oriented programming concept where an object inherits all the properties of another object. Inheritance is the mechanism of code reuse. The object that is getting inherited is called superclass and the object that inherits the superclass is called subclass.

We use extends keyword in java to implement inheritance. Below is a simple example of inheritance in java.

package com.exampractice.java.examples1;

class SampleSuperClassA

{

public void foo()

{

System.out.println("SampleSuperClassA");

}

}

class SampleSubClassB extends SampleSuperClassA{

public void bar(){

System.out.println("SampleSubClassB");

}

}

public class SampleTest {

public static void main(String args[]){

SampleSubClassB a = new SampleSubClassB();

a.foo();

a.bar();

}

}

}

Association

Association is the OOPS concept to define the relationship between objects. Association defines the multiplicity between objects. For example Teacher and Student objects. There is one to many relationship between a teacher and students. Similarly a student can have one to many relationship with teacher objects. However both student and teacher objects are independent of each other.

Aggregation

Aggregation is a special type of association. In aggregation, objects have their own life cycle but there is an ownership. Whenever we have “HAS-A” relationship between objects and ownership then it’s a case of aggregation.

Composition

Composition is a special case of aggregation. Composition is a more restrictive form of aggregation. When the contained object in “HAS-A” relationship can’t exist on it’s own, then it’s a case of composition. For example, House has-a Room. Here room can’t exist without house.