Java Advanced Topics and Techniques

Constructor Chaining in Java

Board Infinity
Board Infinity
Constructor Chaining in Java

    Encapsulation in Java: A Comprehensive Tutorial

    String Array in Java

    Reverse an Array in Java

    Converting Character Array to String in Java

    Pojo Class in Java: How to Create?

    ListSize() in Java

    Try, Catch and Finally in Java

    Constructor Chaining in Java

    Equals and == in Java: Differences

    Abstract Class in Java

    Runnable Interface in Java

    Java Custom Exception

    Hashcode() in Java

    Understanding the difference between JDK, JRE, and JVM

    AWT and SWING in Java

    Difference between JSP and Servlet

    Servlet Life Cycle

    Java Design Pattern: Factory Method

    Collectors toMap() in Java

    Socket Programming in Java: Comprehensive Guide

    Kadane's Algorithm with Java

Introduction

In Java, constructor chaining involves invoking constructors repeatedly after creating an object. We can use this method when we want to invoke multiple constructors at once using only one instance.

This section will discuss Java constructor chaining in depth with appropriate examples.

Constructor Chaining

Constructor chaining is the method of invoking one constructor from another constructor in the same class. The process occurs through inheritance. Whenever we create an instance of a derived class, it invokes all constructors of the base class (inherited class), and then it invokes the constructor of the calling class (derived class).

There are two ways for constructor chaining :

Within the same class: When constructors are from the same class, we use this() method.

Syntax:

this(); or this(parameters list); 

From the base class: When the constructors are from different classes (parent and child), we can use the super() keyword to invoke the base class constructor.

Syntax:

super(); or super(Parameter List);  

Need Constructor chaining in Java

Constructor chaining is a Java programming technique for performing multiple tasks and ordering them by having a separate constructor for each task. A developer can make the program easier to read and understand using this technique.

For example, If we do not use constructor chaining and they require a particular parameter, then we have to initialize it twice in each constructor.

Whenever developers change a parameter, they must make changes inside each constructor.

Note: In Java, one cannot call the constructor directly by name. So if we want to call a constructor, we need to use one of these two keywords mentioned above.

Code Sample

Constructors Chaining within a class using this()

class sample {
    //default constructor
    sample() {
        System.out.println("Default Constructor invoked");
    }
    sample(int n) {
        //Parameterized constructor

        this();
        System.out.println("Parameterized Constructor invoked");
    }
}
public class ThisExample {
    public static void main(String arg[]) {
        sample obj = new sample(5);
    }
}


Output
Default Constructor invoked
Parameterized Constructor invoked

Constructors Chaining from different classes using super()

class sample {
    sample() {
        this(5, 10);
        System.out.println("Invoked Base class default constructor");
    }
    sample(int x, int y) {
        System.out.println("Invoked Base class parameterized constructor");
    }
}
class Example extends sample {
    Example() {
        this("Board", "Infinity");
        System.out.println("Invoked Derived class default constructor");
    }
    Example(String str1, String str2) {
        super();
        System.out.println("Invoked Derived class parameterized constructor");
    }
}
public class ConstructorChaining {
    public static void main(String args[]) {
        Example my_sample = new Example();
    }
}


Output:
Invoked Base class parameterized constructor
Invoked Base class default constructor
Invoked Derived class parameterized constructor
Invoked Derived class default constructor