What is constructor chaining in Java?

In Java, constructor chaining is a sequence of invoking constructors upon initializing an object. It is used when we want to invoke a number of constructors, one after another by using only an instance. In this section, we will discuss constructor chaining in Java in detail with proper examples. Let’s have a quick look at what is a constructor in Java.

Constructor

In Java, a constructor is the same as a method but the only difference is that the constructor has the same name as the class name. It is used to create an instance of the class. It is called automatically when we create an object of the class. It has no return type. Remember that a constructor cannot be abstract, final, synchronized, and static. We cannot override a constructor.

There are two types of constructor in Java:

Default Constructor (also known as a no-argument constructor)
Parameterized Constructor

Constructor Chaining

In constructor chain, a constructor is called from another constructor in the same class this process is known as constructor chaining. It occurs through inheritance. When we create an instance of a derived class, all the constructors of the inherited class (base class) are first invoked, after that the constructor of the calling class (derived class) is invoked.

We can achieve constructor chaining in two ways:

Within the same class: If the constructors belong to the same class, we use this
From the base class: If the constructor belongs to different classes (parent and child classes), we use the super keyword to call the constructor from the base class.

Remember that changing the order of the constructor does not affect the output.

What is constructor chaining in Java

The Need of Constructor Chaining

Suppose, there are five tasks to perform. There are two ways to perform these tasks, either implement all the tasks in a single constructor or create separate tasks in a single constructor.

By using the constructor chaining mechanism, we can implement multiple tasks in a single constructor. So, whenever we face such types of problems, we should use constructor chaining. We can make the program more readable and understandable by using constructor chaining.

Rules of Constructor Chaining

An expression that uses this keyword must be the first line of the constructor.
Order does not matter in constructor chaining.
There must exist at least one constructor that does not use this

Constructor Calling form another Constructor

The calling of the constructor can be done in two ways:

By using this() keyword: It is used when we want to call the current class constructor within the same class.
By using super() keyword: It is used when we want to call the superclass constructor from the base class.

Note: In the same constructor block, we cannot use this() and super() simultaneously.

Let’s understand these two concepts through Java programs.

Constructor Chaining Examples

Calling Current Class Constructor

We use this() keyword if we want to call the current class constructor within the same class. The use of this() is mandatory because JVM never put it automatically like the super() keyword. Note that this() must be the first line of the constructor. There must exist at least one constructor without this() keyword.

Syntax:

For example:

Let’s create a Java program and call the current class constructor.

ConstructorChain.java

  public class ConstructorChain  {  //default constructor  ConstructorChain()  {  this(“Tutoraspire”);  System.out.println(“Default constructor called.”);  }  //parameterized constructor  ConstructorChain(String str)  {  System.out.println(“Parameterized constructor called”);  }  //main method  public static void main(String args[])   {   //initializes the instance of example class  ConstructorChain cc = new ConstructorChain();   }   }   

Output:

What is constructor chaining in Java

In the above example, we have created an instance of the class without passing any parameter. It first calls the default constructor and the default constructor redirects the call to the parameterized one because of this(). The statements inside the parameterized constructor are executed and return back to the default constructor. After that, the rest of the statements in the default constructor is executed and the object is successfully initialized. The following is the calling sequence of the constructor:

  ConstructorChain cc = new ConstructorChain(); -> ConstructorChain() -> ConstructorChain(String str) -> System.out.println() -> ConstructorChain() -> System.out.println()  

Calling Super Class Constructor

Sometimes, we need to call the superclass (parent class) constructor from the child class (derived class) in such cases, we use the super() keyword in the derived class constructor. It is optional to write super() because JVM automatically puts it. It should always write in the first line. We get a syntax error if we try to call a superclass constructor in the child class.

Syntax:

super(): It calls the no-argument or default constructor of the superclass.

super(parameters): It invokes the superclass parameterized constructor.

Remember that the superclass constructor cannot be inherited in the subclass. It can be called from the subclass constructor by using the super keyword.

Let’s create a Java program and implement constructor chaining in an inherited class.

ConstructorChaining.java

  //parent class or base class  class Demo  {  //base class default constructor  Demo()  {  this(80, 90);  System.out.println(“Base class default constructor called”);  }  //base class parameterized constructor  Demo(int x, int y)  {  System.out.println(“Base class parameterized constructor called”);  }  }  //derived class or child class  class Prototype extends Demo  {  //derived class default constructor  Prototype()  {  this(“Java”, “Python”);  System.out.println(“Derived class default constructor called”);  }  //derived class parameterized constructor  Prototype(String str1, String str2)  {  super();  System.out.println(“Derived class parameterized constructor called”);  }  }  public class ConstructorChaining  {  //main method  public static void main(String args[])   {   //initializes the instance of example class  Prototype my_example = new Prototype();  }   }  

Output:

What is constructor chaining in Java

Next TopicAdd elements to Array in Java

What is constructor chaining in Java

What is constructor chaining in Java?

Constructor

Constructor Chaining

The Need of Constructor Chaining

Rules of Constructor Chaining

Constructor Calling form another Constructor

Note: In the same constructor block, we cannot use this() and super() simultaneously.

Constructor Chaining Examples

Calling Current Class Constructor

Calling Super Class Constructor

Non-primitive data types in Java

PHP strcoll() function

You may also like