Constructor Chaining in Java with Examples

What is Constructor Chaining?

Constructor Chaining is the process where one constructor calls another constructor within the same class or from its parent class.

This helps eliminate duplicate initialization code and improves code reusability and readability.

Two Types of Constructor Chaining in Java

Type	Keyword Used	Purpose
Within the same class	this()	Call another constructor in the same class
From the parent class	super()	Call the parent’s constructor

1. Constructor Chaining Using this()

When you call one constructor from another in the same class, use this().

✅ Example:

public class Student {
    private int id;
    private String name;

    // Constructor 1
    public Student() {
        this(1, "Default");
        System.out.println("Default constructor called");
    }

    // Constructor 2
    public Student(int id, String name) {
        this.id = id;
        this.name = name;
        System.out.println("Parameterized constructor called");
    }

    public void show() {
        System.out.println("ID: " + id + ", Name: " + name);
    }

    public static void main(String[] args) {
        Student student = new Student();
        student.show();
    }
}

📌 Output:

Parameterized constructor called
Default constructor called
ID: 1, Name: Default

✅ this(1, "Default") called the parameterized constructor before running the default one.

2. Constructor Chaining Using super()

When you call a constructor from the parent class, use super() — and it must be the first statement in the child constructor.

✅ Example:

class Person {
    public Person(String name) {
        System.out.println("Person constructor called for: " + name);
    }
}

class Employee extends Person {
    public Employee() {
        super("Ramesh");
        System.out.println("Employee constructor called");
    }

    public static void main(String[] args) {
        Employee emp = new Employee();
    }
}

📌 Output:

Person constructor called for: Ramesh
Employee constructor called

✅ super("Ramesh") triggered the parent class constructor before continuing the child class constructor.

Rules of Constructor Chaining

1. ✅ this() and super() must be the first statement in a constructor.
2. ❌ You can’t use both this() and super() in the same constructor.
3. ✅ Compiler automatically adds super() if no explicit call is made.
4. ✅ Helps reduce code duplication by reusing constructors.

Real-World Use Case

Let’s say you’re creating a Product class:

public class Product {
    private int id;
    private String name;
    private double price;

    public Product() {
        this(0, "Unnamed", 0.0); // call full constructor
    }

    public Product(int id, String name) {
        this(id, name, 0.0); // default price
    }

    public Product(int id, String name, double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    public void printInfo() {
        System.out.println(id + " - " + name + " - ₹" + price);
    }

    public static void main(String[] args) {
        Product p = new Product(1, "Laptop");
        p.printInfo();
    }
}

📌 Output:

1 - Laptop - ₹0.0

🔁 Constructor chaining makes the class more flexible to use different constructors with minimal code repetition.

❓ Why Constructor Chaining?

• ✅ Cleaner and DRY constructors
• ✅ Helps build default values
• ✅ Encourages code reuse
• ✅ Reduces bugs from copy-paste logic

 Summary

Concept	Purpose
this()	Calls another constructor in the same class
super()	Calls the parent constructor
DRY principle	Eliminates duplicate code
Used for initialization	Assigning common values in a chain of constructors

Final Thoughts

Constructor chaining is a fundamental OOP concept that makes Java code more elegant, clean, and maintainable.

Next time you write multiple constructors, chain them smartly using this() or super() and make your code shine ✨