Java Constructor Chaining

Calling One Constructor from Another in Java (Constructor Chaining)

Java supports constructor chaining, allowing one constructor to call another within the same class. This promotes code reusability and avoids redundancy. Two primary methods achieve this:

1. this() Keyword:

Use the this() keyword to call another constructor within the same class. This must be the first statement in the calling constructor.

public class MyClass {
    private String name;
    private int age;

    public MyClass(String name) {
        this(name, 0); // Calls the constructor below
    }

    public MyClass(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

2. super() Keyword:

In inheritance, use super() to call a constructor from the superclass. Like this(), it must be the first statement.

public class ChildClass extends ParentClass {
    private String extraData;

    public ChildClass(String name, int age, String extraData) {
        super(name, age); // Calls ParentClass constructor
        this.extraData = extraData;
    }
}

Spring Boot Context:

Constructor injection in Spring Boot leverages these principles. Spring manages bean creation, automatically calling the appropriate constructor based on dependencies. Ensure your Spring beans have a constructor clearly defining dependencies.

@Component
public class MyService {
    private final MyRepository repository;

    public MyService(MyRepository repository) {
        this.repository = repository;
    }
    // ... methods ...
}

This demonstrates constructor chaining's utility in concise and maintainable code. Properly using this() and super() enhances your Java applications, including those built with Spring Boot. Remember, only one constructor call (either this() or super()) is allowed as the first statement.