Constructor chaining in Java is a technique where one constructor calls another constructor in the same or parent class. This process ensures that object initialization is done efficiently, reducing code redundancy and improving maintainability. In Java, constructor chaining can be performed within the same class (using this()) or between a subclass and superclass (using super()).

Types of Constructor Chaining

1. Constructor Chaining Within the Same Class

Example:
class Student {
String name;
int age;

// Constructor 1
Student() {
this("Unknown", 18); // Calling parameterized constructor
}

// Constructor 2
Student(String name) {
this(name, 18); // Calling another constructor
}

// Constructor 3
Student(String name, int age) {
this.name = name;
this.age = age;
}

void display() {
System.out.println("Name: " + name + ", Age: " + age);
}

public static void main(String[] args) {
Student s1 = new Student();
s1.display();

Student s2 = new Student("Alice");
s2.display();

Student s3 = new Student("Bob", 22);
s3.display();
}
}
Explanation:

The no-argument constructor calls the constructor with two arguments using this("Unknown", 18);.

The constructor with a single argument calls another constructor with two arguments using this(name, 18);.

The final constructor initializes the values.

2. Constructor Chaining Between Parent and Child Classes

In this approach, a subclass constructor invokes the constructor of its superclass using super(). This ensures that the base class is properly initialized before initializing the subclass.

Example:
class Person {
String name;

Person(String name) {
this.name = name;
System.out.println("Person Constructor: " + name);
}
}

class Employee extends Person {
int id;

Employee(String name, int id) {
super(name); // Calling superclass constructor
this.id = id;
System.out.println("Employee Constructor: " + id);
}
}

public class Main {
public static void main(String[] args) {
Employee emp = new Employee("John", 101);
}
}
Explanation:

The Employee constructor calls the Person constructor using super(name);.

The Person constructor initializes the name attribute.

Then, the Employee constructor initializes the id attribute.

Benefits of Constructor Chaining

Code Reusability: Eliminates redundant code by calling one constructor from another.

Better Code Organization: Makes object initialization more structured and readable.

Efficient Initialization: Ensures all necessary fields are initialized properly.

Conclusion

Constructor chaining is an essential concept in Java for optimizing object creation. Whether within the same class or across class hierarchies, it enhances code reusability and maintainability. By using this() and super(), developers can streamline their constructor logic, making their Java programs more efficient and cleaner.