Constructors and Constructor Overloading

Default Constructor

If a class defines no constructor at all, the Java compiler automatically inserts a no-argument default constructor that takes no parameters and initializes fields to their default values (0, false, null). As soon as you write even one constructor of your own, however, the compiler stops providing the default one — if you still need a no-argument constructor at that point, you must write it explicitly.

Constructor Overloading

Just like methods, a class can define multiple constructors as long as their parameter lists differ, which is called constructor overloading. This lets client code create objects in different ways depending on what information is available at that moment — for example, creating an object with default values, or with fully specified values.

Constructor Chaining with this()

Inside one constructor, you can call another constructor of the same class using this(...) with matching arguments. This is called constructor chaining, and it lets you centralize common initialization logic in one constructor instead of duplicating it across several. A constructor can make at most one such call. Until Java 24 it had to be the very first statement. Since Java 25 (flexible constructor bodies), statements may come before it, but only ones that do not use the object being built: they cannot use this, read its fields or call its instance methods.

• Constructor name must exactly match the class name, with matching capitalization.
• Constructors never declare a return type, including void.
• A constructor can call this(...) or super(...) once at most; code before that call must not touch the object being built.
• A class loses its free compiler-provided default constructor once any constructor is written explicitly.

Parameterized Constructors and this.field

A parameterized constructor takes the starting values as arguments, so an object is complete the moment it is created. Parameters are usually given the same names as the fields they fill, which hides the fields inside the constructor. Writing this.name = name tells Java to assign the parameter name to the field name of the object being created. Without this., name = name just assigns the parameter to itself and the field keeps its default value.

Validating Arguments in the Constructor

Because every object passes through a constructor, it is the best place to reject bad data. Check the arguments and throw an IllegalArgumentException (or NullPointerException via Objects.requireNonNull) if they make no sense. A caller then can never hold a half-valid object, such as a bank account with a negative balance or a person without a name.

Copy Constructors

A copy constructor takes another object of the same class and copies its values, as in Book(Book other). Java does not generate one for you, but it is a common and readable way to duplicate an object. Copying a field that refers to a mutable object (such as a list) copies only the reference, so for an independent copy, create a new list from the original.

Private Constructors

A constructor can be private, which stops other classes from calling new on it. This is used for utility classes that only hold static methods (like java.lang.Math), and for classes that control how instances are made through a static factory method such as of(...).

Constructors vs Methods

The two look alike, but they play different roles:

• A constructor runs automatically, once per object, when you use new. A method runs only when you call it, as many times as you like.
• A constructor has the class name and no return type. A method can have any name and must declare a return type (or void).
• Constructors are not inherited, although a subclass calls a superclass constructor with super(...). Methods are inherited and can be overridden.

Examples

public class Rectangle {
    int width;
    int height;

    Rectangle() {
        this(1, 1); // chains to the two-argument constructor
    }

    Rectangle(int side) {
        this(side, side); // a square, chains to the two-argument constructor
    }

    Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }

    int area() {
        return width * height;
    }

    public static void main(String[] args) {
        Rectangle r1 = new Rectangle();
        Rectangle r2 = new Rectangle(5);
        Rectangle r3 = new Rectangle(4, 6);

        System.out.println(r1.area());
        System.out.println(r2.area());
        System.out.println(r3.area());
    }
}

1
25
24

class Book {
    String title;
    int pages;

    Book(String title, int pages) {
        if (pages <= 0) {
            throw new IllegalArgumentException("pages must be positive: " + pages);
        }
        this.title = title; // this.title is the field, title is the parameter
        this.pages = pages;
    }

    Book(Book other) { // copy constructor
        this(other.title, other.pages);
    }
}

public class BookDemo {
    public static void main(String[] args) {
        Book original = new Book("Java Basics", 320);
        Book copy = new Book(original);
        copy.title = "Java Basics, 2nd Edition";

        System.out.println(original.title + " (" + original.pages + " pages)");
        System.out.println(copy.title + " (" + copy.pages + " pages)");

        try {
            new Book("Empty", 0);
        } catch (IllegalArgumentException e) {
            System.out.println("Rejected: " + e.getMessage());
        }
    }
}

Java Basics (320 pages)
Java Basics, 2nd Edition (320 pages)
Rejected: pages must be positive: 0

Exercise

Give Point two constructors: one that takes x and y, and a no-argument one that creates the origin by calling the other with this(0, 0).

Expected output: (0, 0) then (3, 4)

class Point {
    int x;
    int y;

    // TODO: Point(int x, int y)
    // TODO: Point() that reuses the constructor above

    String describe() {
        return "(" + x + ", " + y + ")";
    }
}

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

class Point {
    int x;
    int y;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    Point() {
        this(0, 0);
    }

    String describe() {
        return "(" + x + ", " + y + ")";
    }
}

public class PointDemo {
    public static void main(String[] args) {
        System.out.println(new Point().describe());     // (0, 0)
        System.out.println(new Point(3, 4).describe()); // (3, 4)
    }
}

Quick quiz

Interview questions