How Does Constructor Overloading Work?

Constructors are overloaded exactly like methods: several constructors in one class with different parameter lists, and the compiler picks one based on the arguments at the call site. The parameter types are the whole signature — the number of arguments, their types and their order.

The problem that overloading creates is duplication. If four constructors each assign the same four fields, then changing how one field is initialised means editing four places, and forgetting one is a silent bug. The fix is constructor chaining: one constructor does the real work, and the others delegate to it with the this(...) call, filling in defaults for the arguments they do not take.

public class Main {
    public static void main(String[] args) {
        System.out.println(new Point(1, 2));
        System.out.println(new Point(3, 4, 10));
        System.out.println(new Point(5, 6, 10, false));
    }
}

class Point {
    private final int x;
    private final int y;
    private final int z;
    private final boolean visible;

    // The full constructor does the real work.
    Point(int x, int y, int z, boolean visible) {
        this.x = x;
        this.y = y;
        this.z = z;
        this.visible = visible;
    }

    // The others delegate to it, supplying defaults.
    Point(int x, int y) {
        this(x, y, 0, true);
    }

    Point(int x, int y, int z) {
        this(x, y, z, true);
    }

    @Override
    public String toString() {
        return "(" + x + ", " + y + ", " + z + ") visible=" + visible;
    }
}

The output shows all three overloads producing consistent objects, with the defaults coming from a single place. That is the real benefit of chaining: the defaults live in one constructor, so changing them is a one-line edit.

Two design points worth adding. Keeping the full constructor as the one that assigns the fields means the class has exactly one place where the object is built, which is easier to reason about. And if your class is immutable — final fields assigned in every constructor — chaining also removes the risk of forgetting to initialise one of them, because only one constructor assigns anything directly.

this(...) calls another constructor of the same class. It is constructor chaining: the current constructor runs first, and its very first statement hands control to the target constructor, which runs to completion before the current one continues past that line.

There are four rules, and the compiler enforces all of them. The this(...) call must be the first statement in the constructor body — you cannot run any code before it, not even a local variable assignment. It must target a constructor in the same class. There can be at most one such call in a constructor. And it must pass arguments that the target constructor actually accepts, exactly as an ordinary call would.

The distinction with super(...) matters and is commonly confused. this(...) chains to another constructor in the same class. super(...) chains to the constructor of the superclass, and it must also be the first statement — which is why a constructor cannot contain both a this(...) and a super(...) call. When you write this(...), the target constructor is responsible for calling super, and that chain eventually reaches Object.

public class Main {
    public static void main(String[] args) {
        System.out.println(new Point(3, 4));
        System.out.println(new Point(5));
    }
}

class Point {
    private final int x;
    private final int y;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
        System.out.println("Point(x, y) ran");
    }

    Point(int x) {
        this(x, 0);                 // this() delegates to another constructor
        System.out.println("Point(x) ran");
    }
}

The output shows the order precisely. Creating new Point(5) runs the two-argument constructor first — that is where the fields are assigned — and only then does the one-argument constructor print its own message. The delegated-to constructor always completes before the delegating one continues.