Answer.

History of the question:

In Java, the concept of calling one constructor from another (constructor chaining) emerged as a necessity to manage object initialization more flexibly while avoiding code duplication. It allows linking constructors within a single class or through a chain in an inheritance hierarchy.

The issue:

When designing complex classes with many parameters, it is inconvenient and inefficient to copy the initialization logic into each constructor. This leads to code duplication, errors, and reduces system maintainability.

The solution:

In Java, one constructor can call another using the this() keyword for the constructor of the same class, and super() for the constructor of the parent class. This allows centralizing the initialization logic, improving readability, and reducing the likelihood of errors.

Code example:

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

    public Person(String name) {
        this(name, 0); // calling another constructor
    }

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

Key features:

Calling a constructor with this() must be the first line in the constructor
The chain of calls can go both down (to the current class) and up (to parent classes) through super()
Allows centralized management of object initialization

Trick questions.

Can you call a constructor not as the first line of the constructor?

No. The call to this() or super() must always be the first line of the constructor; otherwise, the code will not compile.

What happens if super() is not explicitly called in the subclass constructor?

In this case, Java automatically adds a call to the no-argument constructor of the parent class. If there is no such constructor, the program will not compile.

Code example:

class Base {
    public Base(int x) {}
}
class Derived extends Base {
    public Derived() {} // Error! No Base() constructor without parameters
}

How many times can this() be called in one constructor?

Exactly once and only as the first line. A repeated or not first call will cause a compilation error.

Common mistakes and anti-patterns

Calling this() not as the first line
Incorrectly expecting that the parent constructor will be called with the necessary default parameters
Circular constructor call chain (leads to compilation error)

Real-life example

Negative case

A programmer copies the same initialization into each constructor of the class—upon changing the logic, they must remember to change all constructors.

Advantages:

Quickly implemented

Disadvantages:

Errors when updating the logic, duplication, complicating maintenance

Positive case

A programmer uses the constructor with the maximum number of parameters as the main one, while the others delegate to it via this()—the logic is centralized.