Java Constructors: Initializing Objects with new

Why Constructors Exist

On the previous page you built classes and created objects with new. A constructor is the code that actually runs during that new call. Its one purpose is to hand back an object that is ready to use - all its required fields set, no half-initialized state.

A constructor looks like a method, with two differences: it has the same name as the class, and it has no return type - not even void.

class Point {
    int x;
    int y;

    Point(int x, int y) {     // constructor: same name as class, no return type
        this.x = x;
        this.y = y;
    }
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point(3, 4);   // the constructor runs here
        System.out.println(p.x + ", " + p.y);
    }
}

new Point(3, 4) allocates the object and then runs the constructor body with x = 3 and y = 4. By the time new returns, p is fully initialized.

The this Keyword

Inside the constructor above, the parameters are named x and y - the same as the fields. this.x means "the field x belonging to this object," while plain x refers to the parameter. Without this, x = x would just assign the parameter to itself and leave the field untouched.

class Account {
    String owner;
    double balance;

    Account(String owner, double balance) {
        this.owner = owner;       // field = parameter
        this.balance = balance;
    }
}

public class Main {
    public static void main(String[] args) {
        Account a = new Account("Sam", 100.0);
        System.out.println(a.owner + " has " + a.balance);
    }
}

You only need this when a parameter shadows a field, but many people use it everywhere for clarity. The common mistake is to forget it when names collide - the code compiles, runs, and silently leaves your fields at their defaults (null, 0, false).

The Default Constructor

If you never write a constructor, Java quietly supplies a default constructor: a public, no-argument constructor that does nothing extra. That is why new worked on classes that had no constructor at all.

The catch: as soon as you write any constructor, the free one is gone.

class Box {
    int size;

    Box(int size) {       // now there is NO no-arg constructor
        this.size = size;
    }
}

new Box();   // compile error: no constructor Box() exists

If you still want new Box() to work, declare the no-arg constructor yourself:

class Box {
    int size;

    Box() {               // explicit no-arg constructor
        this.size = 1;
    }

    Box(int size) {
        this.size = size;
    }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new Box().size);     // 1
        System.out.println(new Box(10).size);   // 10
    }
}

Constructor Overloading

A class can have several constructors as long as their parameter lists differ - this is just method overloading applied to constructors. Each one offers a different way to build the object.

class Rectangle {
    int width;
    int height;

    Rectangle() {                 // a default 1x1 square
        this.width = 1;
        this.height = 1;
    }

    Rectangle(int side) {         // a square
        this.width = side;
        this.height = side;
    }

    Rectangle(int width, int height) {   // a full rectangle
        this.width = width;
        this.height = height;
    }

    int area() { return width * height; }
}

public class Main {
    public static void main(String[] args) {
        System.out.println(new Rectangle().area());        // 1
        System.out.println(new Rectangle(5).area());       // 25
        System.out.println(new Rectangle(2, 3).area());    // 6
    }
}

Java picks the matching constructor by the number and types of arguments you pass to new.

Chaining with this()

Notice the duplication above: each constructor assigns fields itself. You can avoid that by having one constructor call another with this(...). The call must be the first statement in the constructor.

class Rectangle {
    int width;
    int height;

    Rectangle() {
        this(1, 1);          // delegates to the two-arg constructor
    }

    Rectangle(int side) {
        this(side, side);    // also delegates
    }

    Rectangle(int width, int height) {   // the single "real" constructor
        this.width = width;
        this.height = height;
    }
}

public class Main {
    public static void main(String[] args) {
        Rectangle r = new Rectangle(4);
        System.out.println(r.width + "x" + r.height);   // 4x4
    }
}

Now the actual initialization lives in one place. The smaller constructors just fill in defaults and forward the work. If you ever try to put a statement before this(...), the compiler rejects it.

Constructors and super()

Every constructor implicitly calls its superclass constructor first. If you write nothing, Java inserts a hidden super() (the no-arg superclass constructor) at the top of the body. You will work with this directly once you start subclassing - which is the next topic.

class Animal {
    String name;
    Animal(String name) { this.name = name; }
}

class Dog extends Animal {
    Dog(String name) {
        super(name);   // must call the parent constructor explicitly here
    }
}

Because Animal has no no-arg constructor, Dog must call super(name) explicitly - there is no free super() to fall back on. Like this(), a super(...) call has to be the first statement in the constructor.

Next: Inheritance

Constructors initialize a single object, but super() already hinted at something bigger: classes can build on other classes, reusing their fields, methods, and constructors. That relationship - one class extending another - is inheritance, and it is the next page.