How do I call one constructor from another in Java?

To call one constructor from another in Java, use the this() keyword within the constructor. This allows you to invoke another constructor in the same class, promoting code reuse and reducing redundancy. Here’s how to do it:

Key Rules:

1. this() must be the first statement in the constructor.
2. Chaining: Constructors can call one another, but cycles (recursive calls) are invalid.
3. Parameter Matching: The arguments passed to this() must match the parameters of the target constructor.

Example: Constructor Chaining

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

    // Primary constructor with all parameters
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Secondary constructor (calls the primary constructor with a default age)
    public Person(String name) {
        this(name, 30); // Calls Person(String name, int age)
    }

    // Default constructor (calls the secondary constructor)
    public Person() {
        this("Unknown"); // Calls Person(String name)
    }
}

How It Works:

1. Person(String name) calls Person(String name, int age) with age = 30.
2. Person() calls Person(String name) with name = "Unknown".

Benefits:

• Avoids code duplication: Centralizes initialization logic in one constructor.
• Maintainability: Changes to initialization only need to be made in one place.
• Flexibility: Supports multiple ways to initialize an object.

Common Use Cases:

1. Default Values: Provide defaults for missing parameters.
2. Validation: Centralize validation logic in a primary constructor.
3. Overloading: Simplify object creation with different parameter sets.

Example: Rectangle Class

public class Rectangle {
    private int width;
    private int height;

    // General constructor
    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }

    // Square constructor (calls the general constructor)
    public Rectangle(int side) {
        this(side, side); // Sets width = height = side
    }
}

Important Notes:

• super() vs. this(): Use super() to call a superclass constructor, but it cannot coexist with this() in the same constructor.
• Error Handling: Ensure parameter validity in the primary constructor to avoid cascading issues.