Constructor vs Method

A constructor looks a lot like a method: a name, parentheses with parameters, and a body in braces. But they do different jobs. A constructor builds an object once; a method does something with an object that already exists, as many times as you like. Mixing them up leads to a classic bug where a "constructor" silently becomes a method.

Point by Point

Both in One Class

public class TicketDemo {
    static class Ticket {
        String name;
        int berth;
        int changes;
 
        Ticket(String name, int berth) {
            this.name = name;
            this.berth = berth;
        }
 
        void moveTo(int newBerth) {
            berth = newBerth;
            changes++;
        }
    }
 
    public static void main(String[] args) {
        Ticket t = new Ticket("Navika", 23);
        t.moveTo(31);
        t.moveTo(32);
        System.out.println(t.name + " in berth " + t.berth
                + " after " + t.changes + " changes");
    }
}

Navika in berth 32 after 2 changes

The constructor ran once, at new. The method moveTo ran twice on the same object.

The void Trap

Adding void to a "constructor" turns it into an ordinary method that happens to share the class's name. The compiler then adds the default constructor, and your setup code never runs:

public class VoidTrap {
    static class Coach {
        int seats;
 
        void Coach() {
            seats = 72;
        }
    }
 
    public static void main(String[] args) {
        Coach c = new Coach();
        System.out.println("Seats: " + c.seats);
    }
}

Seats: 0

How it works

1. Line 5 has a return type, void, so it's a method named Coach, not a constructor.
2. The class now has no constructor, so the compiler adds an empty default one.
3. new Coach() runs that empty constructor; seats keeps its default, 0.

Try it yourself: remove void from line 5 and run it again.

Common Mistakes

Calling a constructor like a method. t.Ticket("Navika", 23) doesn't compile; constructors run only through new, this(...) or super(...).

Expecting constructors to be inherited. A subclass must declare its own constructors (see "Constructor Calls in Inheritance").

Putting long-running work in a constructor. Keep constructors to setup and validation; heavy work belongs in methods.

Interview Corner

Practice

1. Easy: For a Movie class, decide which of these should be the constructor and which should be methods: setting the title, adding a rating, printing details.
2. Harder: Write a Counter class whose constructor sets a starting value and whose method next() returns the next value each time. Call next() three times.

Key Takeaways