Java Constructor in Inheritance

In this article, you will learn about Constructor behavior in Inheritance, in Java with the help of examples.

A Constructor is a member function of a class that allows you to initialize a newly created object of that class type with some initial value and has same name as class with no explicit return type.

Whenever a class (sub class) extends another class (super class), a subclass inherits all the members (fields, methods, and nested classes) from its super class.

Constructors are not members, so they are not inherited by a subclass, but the constructor of the super class can be invoked from the sub class.

Creating Subclass Instance

When we create an object of a subclass, both subclass and superclass members get memory in subclass object.

The main motive of a constructor is to initialize the member variables of a class. So both the constructor needs to be executed because this object (subclass) contains member variables of both classes. In Java, the super class constructor is always called before the current constructor.

Parent Class Default Constructor

In Java, the constructor of super class with no argument (default constructor) gets automatically called in subclass constructor.

Example
class A {
    //default constructor
    A() {
        System.out.println("A Class Constructor Called ");
    }
}

class B extends A {
    B() {
        System.out.println("B Class Constructor Called ");
    }
}

class Main {
    public static void main(String[] args) {
        //creating B class instance
        B obj = new B();
    }
}
Output
A Class Constructor Called 
B Class Constructor Called
Example explained

When we create an object of B (Sub class), B class constructor will call and
before executing its code it will invoke default constructor of super class.

Super Keyword

To call superclass constructor in subclass explicitly we make use of super keyword. But super() must be the first statement in subclass constructor.

Calling parent class default constructor

When the super class has a default constructor, it is not necessary to call it using the super keyword. It is called automatically.

Example
class A {
    A() {
        System.out.println("A Class Constructor Called ");
    }
}

class B extends A {

    B() {
       //must be the first statement 
        super();  //optional
        System.out.println("B Class Constructor Called ");
    }
}

class Main {
    public static void main(String[] args) {
        B obj = new B();
    }
}
Output
A Class Constructor Called 
B Class Constructor Called

Calling parent class parameterized constructor

If we want to call parameterized constructor of superclass in subclass, then we must call it using super().

Example
class A {
    int a;

    A(int x) {
        a = x;
    }
}

class B extends A {
    int b;

    B(int x, int y) {
       //must be the first statement 
        super(x);
        b = y;
    }

    void show() {
        System.out.println("a = " + a + ", b = " + b);
    }
}

class Main {
    public static void main(String[] args) {
        B obj = new B(10, 20);
        obj.show();

    }
}
Output
a = 10, b = 20
Example explained

When we create an object of B (sub class), B class parameterized constructor will call and before executing its code it will execute the parameterized constructor of super class after reading  super(x) statement.

 

Default Constructor Example in Multilevel Inheritance

public class Main {

    public static void main(String arg[]) {        
        A a = new A();
        System.out.println("********************");
        B b = new B();
        System.out.println("********************");
        C c = new C();       
    }
}

class A {
    A() {
        System.out.println("Constructor A called");
    }
}

class B extends A {
    B() {
        System.out.println("Constructor B called");
    }
}

class C extends B {
    C() {
        System.out.println("Constructor C called");
    }
}
Output
Constructor A called
********************
Constructor A called
Constructor B called
********************
Constructor A called
Constructor B called
Constructor C called

Parameterized Constructor Example in Multilevel Inheritance

public class Main {
    public static void main(String arg[]) {
        A x = new A(10);
        System.out.println("********************");
        B y = new B(10, 20);
        System.out.println("********************");
        C z = new C(10, 20, 30);
    }
}

class A {
    int i;

    A(int i) {
        this.i = i;
        System.out.println("Constructor A called");
    }
}

class B extends A {
    int j;

    B(int i, int j) {
        super(i);
        this.j = j;
        System.out.println("Constructor B called");
    }
}

class C extends B {
    int k;

    C(int i, int j, int k) {
        super(i, j);
        this.k = k;
        System.out.println("Constructor C called");
    }
}
Output
Constructor A called
********************
Constructor A called
Constructor B called
********************
Constructor A called
Constructor B called
Constructor C called

If a super class contains two or more constructors, but one of them is a default constructor which does not take any parameters, then it is not necessary to call it using the super keyword. It is called automatically.

Example
public class Main {
    public static void main(String arg[]) {
        A a = new A(10);
        System.out.println("********************");
        B b = new B(20);
        System.out.println("********************");
        C c = new C(30);
    }
}

class A {
    int i;

    A(int i)    //CONSTRUCTOR 1 - PARAMETERIZED CONSTRUCTOR
    {
        this.i = i;
        System.out.println("Class A parameterized Constructor is called");
    }

    A()    //CONSTRUCTOR 2 - DEFAULT CONSTRUCTOR
    {
        i = 100;
        System.out.println("Class A default Constructor is called");
    }

}

class B extends A {
    int j;

    B(int j) {
        //call CONSTRUCTOR 2, which is a default constructor.
        this.j = j;        
        System.out.println("Class B Constructor is called");
    }
}

class C extends A {
    C(int i) { 
        super(i); //call CONSTRUCTOR 1
        System.out.println("Class C Constructor is called");
    }
}
Output
Class A parameterized Constructor is called
********************
Class A default Constructor is called
Class B Constructor is called
********************
Class A parameterized Constructor is called
Class C Constructor is called

If a super class contains two or more constructors and there is no default constructor, it is required that the sub class constructor specifically call the required super class constructor using super keyword.

Example
class A
{
    int i;
    int j;

    A(int i)    //CONSTRUCTOR 1
    {
        this.i = i;
        j = i;
    }

    A(int i, int j)    //CONSTRUCTOR 2
    {
        this.i = i;
        this.j = j;
    }

}

class B extends A
{
    int j;
    B(int j)
    {
        //show compilation error that there is no default constructor
        this.j = j;
    }
}

class C extends A
{
    C(int i)
    {
        super(i); // CONSTRUCTOR 1 called
    }
}

Points to remember:

  • Constructors are not inherited by the subclass but can be invoked from the sub class.
  • The super class constructor is always called before the current constructor.
  • Explicit call to super class constructor from sub class constructor can be made using super keyword.
  • Call to super class constructor using super keyword must be the first statement in the sub class constructor.
  • The default constructor (with no argument) of super class  gets automatically called in subclass constructor. So there is no need to explicitly call default constructor of parent class using super keyword.
  • If we want to call parameterized constructor of super class in sub class, then we must call it explicitly using super keyword.

Leave a Reply