Understanding Constructor Chaining in Java with Examples

Constructor chaining java, explain and give code demonstration

Constructor chaining in Java is a technique where one constructor calls another constructor in the same class or in a superclass. This allows for code reuse and helps to avoid duplication. Constructor chaining can be achieved using the this() keyword to call another constructor in the same class or the super() keyword to call a constructor from the superclass.

Key Points:

1. Within the Same Class: You can call another constructor in the same class using this().
2. In Superclass: You can call a constructor from the superclass using super().
3. Order of Execution: If both this() and super() are used, super() must be called first, and it can only be called in the first line of the constructor.

Example Code Demonstration

Here’s a simple example demonstrating constructor chaining in Java:

class Animal {
    String name;

    // Superclass constructor
    Animal(String name) {
        this.name = name;
        System.out.println("Animal constructor called: " + name);
    }
}

class Dog extends Animal {
    String breed;

    // Subclass constructor that calls the superclass constructor
    Dog(String name, String breed) {
        super(name); // Call to superclass constructor
        this.breed = breed;
        System.out.println("Dog constructor called: " + name + ", Breed: " + breed);
    }

    // Another constructor in the subclass that uses constructor chaining
    Dog(String name) {
        this(name, "Unknown Breed"); // Call to another constructor in the same class
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog1 = new Dog("Buddy", "Golden Retriever");
        System.out.println();
        Dog dog2 = new Dog("Max");
    }
}

Explanation of the Code:

1. Animal Class: This is the superclass with a constructor that takes a String parameter for the animal's name.
2. Dog Class: This is a subclass of Animal. It has two constructors:
   • The first constructor takes both name and breed parameters. It calls the superclass constructor using super(name) to initialize the name field.
   • The second constructor takes only the name parameter and uses constructor chaining to call the first constructor with a default breed of "Unknown Breed".
3. Main Class: In the main method, two Dog objects are created. The first one provides both name and breed, while the second one only provides the name, demonstrating how constructor chaining works.

Output:

When you run the above code, the output will be:

Animal constructor called: Buddy
Dog constructor called: Buddy, Breed: Golden Retriever

Animal constructor called: Max
Dog constructor called: Max, Breed: Unknown Breed

This output shows that the constructors are called in the correct order, demonstrating the concept of constructor chaining effectively.