Constructor Chaining in Java

Last Updated: 1 August, 2023

Constructor chaining refers to the process of calling one constructor from another constructor in Java by using the this() or super() keywords.

Uses of the this() and super() keywords in constructor chaining:

By using the this() keyword: If we need to call a constructor from another constructor within the same class, we can use the this() keyword.
By using the super() keyword: In inheritance, if we need to call a parent class constructor from the child class constructor, the super() keyword is used.

Let's see an example of constructor chaining using the this() keyword.

Example 1: Constructor Chaining with this() keyword

  public class Employee {
    public String empName;
    public int empID;
    public String designation;
  
    // default constructor
    public Employee() {
      // calling constructor with String parameter
      this("Kavish");
      System.out.println("Default constructor called...");
    }
  
    // Parameterized constructor with one parameter
    public Employee(String name) {
      // calling constructor with String, int parameters
      this(name, 195);
      System.out.println("Constructor with one parameter called...");
    }
  
    // Parameterized constructor with two parameters
    public Employee(String name, int empId) {
      // calling constructor with String, int, String parameters
      this(name, empId, "Manager");
      System.out.println("Constructor with two parameters called...");
    }
  
    // Parameterized constructor with three parameters
    public Employee(String empName, int empId, String designation) {
      System.out.println("Constructor with three parameters called...");
      this.empName = empName;
      this.empID = empId;
      this.designation = designation;
    }
  
    void printEmployeeRecord() {
      System.out.println("\nEmployee Name: " + empName);
      System.out.println("Employee ID: " + empID);
      System.out.println("Employee Designation: " + designation);
    }
  
    public static void main(String[] args) {
      Employee empObj = new Employee();
      empObj.printEmployeeRecord();
    }
  }

Output

Constructor with three parameters called...
Constructor with two parameters called...
Constructor with one parameter called...
Default constructor called...

Employee Name: Kavish
Employee ID: 195
Employee Designation: Manager

Let's see an example of constructor chaining using the super() keyword.

Example 2: Constructor Chaining with super() keyword

  class Parent {
    public Parent() {
      System.out.println("Parent class - Default constructor called");
    }
  
    public Parent(String name) {
      System.out.println("Parent class - Parameterized constructor value: " + name);
    }
  }
  
  class Child extends Parent {
    public Child() {
      // the default constructor of the Parent class is called by default.
      System.out.println("Child class - Default constructor\n");
    }
  
    public Child(String name) {
      super(); // super() method will call the default constructor of the Parent class.
      System.out.println("Child class - Parameterized constructor value: " + name + "\n");
    }
    
    public Child(int x, int y) {
      super("My Test Data"); // super() method will call Parent class String parameterized constructor.
      System.out.println("Child class - two Parameterized (int, int) constructor value: " + x + " " + y);
    }
  }
  
  public class Output {
    public static void main(String arg[]) {
      // Calling Child class with default constructor
      Child child1 = new Child();
      
      // Calling Child class with single parameterized constructor
      Child child2 = new Child("Test");
      
      // Calling Child class with two parameterized constructor
      Child child3 = new Child(10, 20);
    }
  }

Output

Parent class - Default constructor called
Child class - Default constructor

Parent class - Default constructor called
Child class - Parameterized constructor value: Test

Parent class - Parameterized constructor value: My Test Data
Child class - two Parameterized (int, int) constructor value: 10 20

Example 3: Constructor Chaining with this() and super() methods

  class Parent {
    // Default constructor
    Parent() {
      // Calling two int parameters constructor from the same class (Parent class)
      this(10, 20);
      System.out.println("Parent class - Default constructor called.");
    }
  
    // Parameterized constructor
    Parent(int num1, int num2) {
      System.out.println("Parent class - Parameterized constructor, Values :" + num1 + " " + num2);
    }
  }
  
  class Child extends Parent {
    // Default constructor
    Child() {
      // Calling two String parameters constructor from the same class (Child class)
      this("Java", "Python");
      System.out.println("Child class - Default constructor called");
    }
  
    // Parameterized constructor
    Child(String str1, String str2) {
      super(); // Calling Parent class default constructor
      System.out.println("Child class - Parameterized constructor, Values: " + str1 + " " + str2);
    }
  }
  
  public class Example {
    public static void main(String args[]) {
      // Initializes the instance of example class
      Child object = new Child();
    }
  }

Output

Parent class - Parameterized constructor, Values :10 20
Parent class - Default constructor called.
Child class - Parameterized constructor, Values: Java Python
Child class - Default constructor called

Example 4: Order of Constructors execution in Inheritance

  class A {
    public A() {
      System.out.println("A - default constructor");
    }
  }
  
  class B extends A {
    public B() {
      System.out.println("B - default constructor");
    }
  }
  
  class C extends B {
    public C() {
      System.out.println("C - default constructor");
    }
  }
  
  public class Result {
    public static void main(String[] args) {
      C cObj = new C();
    }
  }

Output

A - default constructor
B - default constructor
C - default constructor

Constructor Chaining in Java

Currently No Video available