Constructor Chaining in Java with Examples & Implementation

In Java, Constructors can be understood as blocks of code used to initialise newly created objects. A constructor is similar to instance methods in Java. However, there is a crucial difference between Constructors and methods in Java – while methods have a return type, Constructors do not have any specific return type. Programmers often refer to Constructors as a special type of method in Java.

Constructors in Java have same name as the class, and they look like the following: 

public class myProgram{

   //This is the constructor

   myProgram(){

   }

   ..

}

When a constructor is called from within another constructor, that is when Constructor Chaining occurs in Java. However, before we dive deeper into Constructor Chaining, let’s first have a quick look at how Constructors work in Java, along with some examples to solidify your understanding. 

How Do Constructors in Java Work? 

To understand how Constructors work, let’s look at an example. Suppose we have a class named myProgram. Now, when we create the object of this class, we will have to write the following statement: 

myProgram obj = new myProgram()

As you can see, the new keyword used in the above example creates the object of myProgram and invokes a constructor to initialise this newly created object. 

If this sounds a little confusing to you, fret not. Let’s look at a simple constructor program in Java to better understand the working of Constructors in Java. 

Basic Constructor Program in Java

Look at the following piece of Java code that uses Constructors: 

public class Test{

   String book;

   //Constructor

   Test(){

      this.book = “A Catcher in the Rye”;

   }

   public static void main(String[] args) {

      Test obj = new Test();

      System.out.println(obj.book);

   }

}

Output:

A Catcher in the Rye

In the above program, we have created an object named ‘obj’ of our class Program. Then, we printed the instance variable name of this newly created object. As you can see from the output, the output is the same as the value passed to ‘book’ during the Constructor’s initialization. 

What this shows is that the moment the obj object was created, the Constructor got automatically invoked. Here, we used the ‘this’ keyword to refer to the current object. There are more ways to do this, too, which we will talk about later in the article while discussing Constructor Chaining. 

With the basics of Constructor in Java settled, let’s move on to Constructor Chaining in Java and how it works! 

Essentials of Constructor Chaining in Java

When we call a Constructor from another Constructor of the same class, what happens is known as Constructor Chaining. The primary purpose of doing Constructor Chaining is to pass parameters through a bunch of different constructors and only initialise them in one place. This way, you get a chance to maintain all of your initialisations in a single location while different constructors can be provided to the users.

If you don’t perform Constructor Chaining and two different Constructors require one parameter, you will need to initialise that parameter twice. Plus, every time the initialisation changes, you will need to make respective changes to all the constructors instead of just one. 

As a rule of thumb, you should always call Constructors with more arguments from Constructors that have fewer arguments. You also must be aware that we can overload multiple Constructors in the class. However, at the time an object is created, only one particular Constructor gets called. There can be quite a few situations while programming in Java where you would need to call multiple constructors from one another without creating different objects. This mechanism of invoking one Constructor from another constructor and when that involved Constructor invokes another constructor is known as constructor chaining.

Learn Software Courses online from the World’s top Universities. Earn Executive PG Programs, Advanced Certificate Programs, or Masters Programs to fast-track your career.

There are two primary things that you should keep in mind regarding Constructor Chaining to ensure utmost clarity: 

• The primary purpose of Constructor Chaining is to maintain the code. The idea is to help you write only one piece of code which can be reused across your program. This way, not only will your code be clean and readable, but it will also be a lot easier to manage with all the corrections and changes happening only to one location instead of all the Constructors. 
• The Constructor that has been invoked does not create a separate object. Instead, it uses the currently running object to invoke another constructor. It is just like calling a different method inside your Constructor, except it is also a constructor.

As you saw in the earlier example, we used this keyword to access the parameters of the Constructor. Likewise, Constructor Chaining also requires primarily two keywords. Here are those two keywords: 

• this – Its method representation calls a current class constructor.
• super – Its method representation calls an immediate super or parent superclass constructor.

In addition, you should be aware of a couple of other important terms and definitions in terms of Constructor Chaining in Java: 

• Constructor Invocation: When you invoke a Constructor, and that Constructor gets successfully invoked, it is known as Constructor Invocation. 
• Constructor Execution: If on invoking Constructor, control starts executing the statements in the Constructor body. It is known as constructor execution.

Key Rules of Constructor Chaining in Java

With the basics of Constructor Chaining settled, let’s look at some essential rules of working with Constructor Chaining in Java: 

• this() can only call the parameters belonging to the same Constructor.
• super() can only call the immediate superclass Constructor.
• this() and super() should be the first statement in the Constructor.
• This () and super() can’t be used within the same Constructor since both individuals need to be first statements, which is not practically possible. 
• You cannot add this() in all the Constructors of the same class, as there should be at least one Constructor without this() statement.
• The invoking and executing of Constructors in Java happens oppositely. So, if the Constructors were called in the order A, B, C, then the execution will be in the C, B, A order. 

For example, here, we have two separate classes that are working by overloading different Constructors. We want to execute the constructors in 2, 1, 4, 3, 5 order.

To execute constructors in order, we need to call the constructors exactly in opposite order like 5, 3, 4, 1, 2, see in the below example.

class Parent

{

Parent()// 1

{

this(“hello”);

System.out.println(“in Parent 0 arg constructor 1”);

}

Parent(String msg)// 2

{

System.out.println(“in Parent(String) constructor 2”);

}

}

class Constructor extends Parent

{

Constructor()// 3

{

this(10);// calling 5 number constructor

System.out.println(“in Constructor 0 arg constructor 3”);

}

Constructor(String msg)// 4

{

super();//calling 1 number parent class constructor

System.out.println(“in Constructor(String msg) arg constructor 4”);

}

Constructor(int i)// 5

{

this(“hello”);//calling 4 number constructor

System.out.println(“in Constructor(int i) constructor 5”);

}

 // main() method

public static void main(String[] args)

{

Constructor cobj = new Constructor(); // calling 3 number constructor

}

}

Output:

in Parent(String) constructor 2  

in Parent 0 arg constructor 1

in Constructor(String msg) arg constructor 4

in Constructor(int i) constructor 5

in Constructor 0 arg constructor 3

Summing up all the concepts of Constructors and Constructor Chaining in Java with one final example: 

class Emp

{   

    public String EName;

    public int EEarnings;

    public String address;

    public Emp()

    {

        this(“Rahul”);

    }

    public Emp(String name)

    {

     this(name, 140035);

    }

    public Emp(String name, int sal)

    {

     this(name, sal, “New Delhi”);

    }

    public Employee(String name, int sal, String add)

    {

     this.EName=name;

     this.EEarnings=sal;

     this.address=add;

    }

    void disp() {

     System.out.println(“Name: “+EName);

     System.out.println(“Salary: “+EEarnings);

     System.out.println(“Address: “+address);

    }

    public static void main(String[] args)

    {

        Employee obj = new Employee();

        obj.disp();

    }

}

Output:

Employee Name: Rahul

Employee Salary: 140035

Employee Address: New Delhi

Conclusion

With that, we come to the end of this article. We hope this clarified your doubts on Constructor Chaining in Java and solidified your understanding further. At upGrad, we believe in helping students from around the globe reach their full potential and succeed in their careers. Our courses are designed keeping in mind both freshers and experienced professionals. 

One such course is upGrad’s Job-linked PG Certification in Software Engineering, specifically designed for first-time job seekers. Check out the course content and get yourself enrolled today! Learn all the relevant Software Engineering skills like Java, DSA, OODAP, JavaScript, MERN, AWS, etc., from industry experts and leading professionals. 

Prepare for a Career of the Future

Apply Now for Executive Post Graduate Programme in Software Development