Inheritance in Java
Inheritance is one of the key features of Object Oriented Programming. Inheritance provided
mechanism that allowed a class to inherit property of another class. When a Class extends
another class it inherits all non-private members including fields and methods. Inheritance in
Java can be best understood in terms of Parent and Child relationship, also known as Super
class(Parent) and Sub class(child) in Java language.
Inheritance defines is-a relationship between a Super class and its Sub class. extends and
implements keywords are used to describe inheritance in Java.
Let us see how extend keyword is used to achieve Inheritance.
class Vehicle.
{
......
}
class Car extends Vehicle
{
....... //extends the property of vehicle class.
}
Now based on above example. In OOPs term we can say that,
Vehicle is super class of Car.
Car is sub class of Vehicle.
Car IS-A Vehicle.
Purpose of Inheritance
1. To promote code reuse.
2. To use Polymorphism.
Simple example of Inheritance
class Parent
{
public void p1()
{
System.out.println("Parent method");
}
}
public class Child extends Parent {
public void c1()
{
System.out.println("Child method");
}
public static void main(String[] args)
{
Child cobj = new Child();
cobj.c1(); //method of Child class
cobj.p1(); //method of Parent class
}
}
Output :
Child method
Parent method
Another example of Inheritance
class Vehicle
{
String vehicleType;
}
public class Car extends Vehicle {
String modelType;
public void showDetail()
{
vehicleType = "Car"; //accessing Vehicle class member
modelType = "sports";
System.out.println(modelType+" "+vehicleType);
}
public static void main(String[] args)
{
Car car =new Car();
car.showDetail();
}
}
Output :
sports Car
Types of Inheritance
1. Single Inheritance
2. Multilevel Inheritance
3. Heirarchical Inheritance
NOTE :Multiple inheritance is not supported in java
Why multiple inheritance is not supported in Java
To remove ambiguity.
To provide more maintainable and clear design.
super keyword
In Java, super keyword is used to refer to immediate parent class of a class. In other words
super keyword is used by a subclass whenever it need to refer to its immediate super class.
Example of Child class refering Parent class property using super keyword
class Parent
{
String name;
}
public class Child extends Parent {
String name;
public void details()
{
super.name = "Parent"; //refers to parent class member
name = "Child";
System.out.println(super.name+" and "+name);
}
public static void main(String[] args)
{
Child cobj = new Child();
cobj.details();
}
}
Output :
Parent and Child
Example of Child class refering Parent class methods using super keyword
class Parent
{
String name;
public void details()
{
name = "Parent";
System.out.println(name);
}
}
public class Child extends Parent {
String name;
public void details()
{
super.details(); //calling Parent class details() method
name = "Child";
System.out.println(name);
}
public static void main(String[] args)
{
Child cobj = new Child();
cobj.details();
}
}
Output :
Parent
Child
Example of Child class calling Parent class constructor using super keyword
class Parent
{
String name;
public Parent(String n)
{
name = n;
}
}
public class Child extends Parent {
String name;
public Child(String n1, String n2)
{
super(n1); //passing argument to parent class constructor
this.name = n2;
}
public void details()
{
System.out.println(super.name+" and "+name);
}
public static void main(String[] args)
{
Child cobj = new Child("Parent","Child");
cobj.details();
}
}
Output :
Parent and Child
Super class reference pointing to Sub class object.
In context to above example where Class B extends class A.
A a=new B();
is legal syntax because of IS-A relationship is there between class A and Class B.
Q. Can you use both this() and super() in a Constructor?
NO, because both super() and this() must be first statement inside a constructor. Hence we
cannot use them together.
Aggregation (HAS-A)
HAS-A relationship is based on usage, rather than inheritance. In other words, class A has-a
relationship with class B, if code in class A has a reference to an instance of class B.
Example
class Student
{
String name;
Address ad;
}
Here you can say that Student has-a Address.
Student class has an instance variable of type Address. Student code can use Address reference
to invoke methods on the Address, and get Address behavior.
Aggregation allow you to design classes that follow good Object Oriented practices. It also
provide code reusability.
Example of Aggregation
class Author
{
String authorName;
int age;
String place;
Author(String name,int age,String place)
{
this.authorName=name;
this.age=age;
this.place=place;
}
public String getAuthorName()
{
return authorName;
}
public int getAge()
{
return age;
}
public String getPlace()
{
return place;
}
}
class Book
{
String name;
int price;
Author auth;
Book(String n,int p,Author at)
{
this.name=n;
this.price=p;
this.auth=at;
}
public void showDetail()
{
System.out.println("Book is"+name);
System.out.println("price "+price);
System.out.println("Author is "+auth.getAuthorName());
}
}
class Test
{
public static void main(String args[])
{
Author ath=new Author("Me",22,"India");
Book b=new Book("Java",550,ath);
b.showDetail();
}
}
Output :
Book is Java.
price is 550.
Author is me.
Q. What is Composition in java?
Composition is restricted form of Aggregation. For example a class Car cannot exist without
Engine.
class Car
{
private Engine engine;
Car(Engine en)
{
engine = en;
}
}
Q. When to use Inheritance and Aggregation?
When you need to use property and behaviour of a class without modifying it inside your class.
In such case Aggregation is a better option. Whereas when you need to use and modify property
and behaviour of a class inside your class, its best to use Inheritance.
