Constructors

When you check into a good hotel, the room is ready before you open the door. The bed is made, fresh towels are on the rack, the air conditioner is set and a key card is waiting at the desk. Nobody expects you to walk into an empty shell and arrange the furniture yourself.

Java objects deserve the same welcome. When your program creates an object, some code should run first to fill in its fields and make it ready for use. That code is the constructor. Here you will learn the kinds of constructors Java offers, how one constructor can call another, and what the JVM does, in order, between the word new and the moment your variable holds a finished object.

What is a Constructor?

A constructor looks a lot like a method, but it has three special traits. Its name must match the class name exactly. It has no return type, not even void. And you never call it by name like room.HotelRoom(); the new keyword calls it for you.

Java code works with three kinds of constructor:

• Default constructor. If you write no constructor at all, the compiler quietly adds an empty one with no parameters. It just calls the parent's constructor and leaves fields at their default values.
• No-arg constructor. A constructor you write yourself that takes no parameters but sets sensible starting values.
• Parameterised constructor. A constructor that takes arguments, so the caller decides the starting values.

Why are Constructors used?

Without constructors, every object would begin with zeros and nulls, and the caller would have to remember to set each field by hand. Sooner or later someone forgets one, and a half-built object sneaks into the system.

Constructors fix this in several ways:

• Guaranteed setup. The code runs on every new, so no object can skip it.
• Required values. A parameterised constructor forces the caller to supply important data, such as a room number, at creation time.
• Validation in one place. You can reject bad input, like a negative price, before the object ever exists.
• Immutable objects. final fields can only be assigned once, and the constructor is the place to do it.
• Less repeated code. Constructor chaining lets several constructors share one block of setup logic.

Real-Life Example

Think about housekeeping in a hotel. When a room is booked, the housekeeping team prepares it before the guest arrives. There is a standard routine for a walk-in guest: one bed, basic toiletries, the usual rate. That is the no-arg constructor. When a guest books ahead with special requests, such as an extra bed or a sea view, the team prepares the room to that order. That is the parameterised constructor.

The building itself must be in place before any room is prepared, just as a parent class is set up before its child class. And the key card is handed over only after the room is fully ready, the same way new hands your variable a reference only after the constructor has finished.

java
class ClassName {
    Type field;

    ClassName() {                   // no-arg
        field = startingValue;
    }

    ClassName(Type field) {         // parameterised
        this.field = field;
    }

    ClassName(Type field, int x) {
        this(field);                // chain to another constructor
        // extra setup
    }
}

ClassName obj = new ClassName(value);

How Constructors Work

A lot happens between typing new and getting a usable object back. Here is the path the JVM follows.

text
   new HotelRoom(305)
          |
          v
+--------------------------+
| Class loaded, if needed  |
+--------------------------+
          |
          v
+--------------------------+
| Heap memory reserved     |
+--------------------------+
          |
          v
+--------------------------+
| Fields set to defaults   |
| 0, 0.0, false, null      |
+--------------------------+
          |
          v
+--------------------------+
| this() or super() runs   |
+--------------------------+
          |
          v
+--------------------------+
| Field initialisers run   |
+--------------------------+
          |
          v
+--------------------------+
| Constructor body runs    |
+--------------------------+
          |
          v
+--------------------------+
| Reference returned       |
+--------------------------+

First the JVM makes sure the class is loaded. It then reserves space on the heap and fills every field with its default: numbers become zero, booleans become false and references become null. Next the constructor's first statement runs, which is either your this(...) call or a super(...) call, written by you or inserted by the compiler. Once the parent part of the object is ready, field initialisers such as int beds = 1; run, and then the rest of the constructor body. Only at the very end does the expression new HotelRoom(305) produce a reference that you can store in a variable.

This order explains a useful rule. You can never have both this() and super() in one constructor, because each one must be the first statement. A constructor that calls this() delegates the super() call to the constructor it chains into.

java
class HotelRoom {
    int number;
    String type;
    double rate;

    HotelRoom() {
        number = 101;
        type = "Standard";
        rate = 2500.0;
    }

    HotelRoom(int number, String type, double rate) {
        this.number = number;
        this.type = type;
        this.rate = rate;
    }

    String describe() {
        return "Room " + number + " " + type + " Rs " + rate;
    }
}

public class RoomDesk {
    public static void main(String[] args) {
        HotelRoom walkIn = new HotelRoom();
        HotelRoom booked = new HotelRoom(305, "Suite", 7800.0);
        System.out.println(walkIn.describe());
        System.out.println(booked.describe());
    }
}

text
Room 101 Standard Rs 2500.0
Room 305 Suite Rs 7800.0

java
class Minibar {
    int bottles;
    boolean restocked;
    String brand;
}

public class MinibarCheck {
    public static void main(String[] args) {
        Minibar bar = new Minibar();
        System.out.println("bottles   = " + bar.bottles);
        System.out.println("restocked = " + bar.restocked);
        System.out.println("brand     = " + bar.brand);
    }
}

text
bottles   = 0
restocked = false
brand     = null

java
class Floor {
    String name;

    Floor(String name) {
        this.name = name;
        System.out.println("Floor ready: " + name);
    }
}

class GuestRoom extends Floor {
    int beds;

    GuestRoom() {
        this(1);
        System.out.println("No-arg: default single bed");
    }

    GuestRoom(int beds) {
        super("Second");
        this.beds = beds;
        System.out.println("GuestRoom with " + beds + " bed(s)");
    }
}

public class ChainDemo {
    public static void main(String[] args) {
        new GuestRoom();
        System.out.println("---");
        new GuestRoom(2);
    }
}

text
Floor ready: Second
GuestRoom with 1 bed(s)
No-arg: default single bed
---
Floor ready: Second
GuestRoom with 2 bed(s)

Constructor vs Method

Common Mistakes

• Losing the default constructor. As soon as you write any constructor, the compiler stops adding the empty one. Code that still calls new HotelRoom() will fail to compile until you write a no-arg version yourself.
• Forgetting `this.` on shadowed names. Writing rate = rate; assigns the parameter to itself, and the field stays at 0.0.
• Putting `this()` or `super()` second. Either call must be the first line of the constructor, or the code does not compile.
• Chaining in a circle. If two constructors call each other with this(), the compiler reports a recursive constructor invocation.
• Calling overridable methods from a constructor. A subclass version may run before the subclass fields are set, and it will see zeros and nulls.

Interview Questions

Summary

• A constructor has the class name, no return type, and runs automatically on new.
• Java has default, no-arg and parameterised constructors, and you can overload them.
• The compiler adds a default constructor only when you write none.
• this() chains to another constructor of the same class, and super() chains to the parent.
• The JVM reserves memory, sets field defaults, runs the chained call, runs field initialisers and then the body.
• Constructors are the right place for validation and for assigning final fields.

Related Topics

• Object: how objects are created and used once they exist.
• this Keyword: more uses of this, beyond constructor chaining.
• super Keyword: calling parent constructors and methods.
• Inheritance: why a parent is always built before its child.