Java With Us

Constructors in Java — <code>this</code>, <code>super</code>, Overloading

Updated on 2026-04-21 Reviewed by the Java With Us editorial team

A constructor is a special method that runs when you new an object. It has the same name as the class, no return type (not even void), and its job is to initialise the new instance.

Basic shape

public class User {
    private final String name;
    private final int age;

    public User(String name, int age) {
        this.name = name;
        this.age  = age;
    }
}

var u = new User("Alice", 30);

The default constructor

If you declare no constructor, Java provides a public no-arg one. The moment you declare any constructor, the default disappears:

public class Foo {
    public Foo(int x) { ... }
}
new Foo();     // ❌ compile error — no no-arg constructor

Overloading and this(...)

public class Rectangle {
    private final int w, h;

    public Rectangle(int w, int h) {
        this.w = w;
        this.h = h;
    }
    public Rectangle(int side) {
        this(side, side);              // delegate — avoids duplicating validation
    }
}

this(...) must be the first statement of a constructor. You can't call this() twice.

super(...) — the parent constructor

public class Admin extends User {
    private final List<String> roles;

    public Admin(String name, int age, List<String> roles) {
        super(name, age);                       // call parent
        this.roles = List.copyOf(roles);
    }
}

If you don't write super(...), the compiler inserts an implicit super(). If the parent has no no-arg constructor, you must call super(...) explicitly.

Private constructor — singletons and utility classes

public final class MathUtils {
    private MathUtils() {}                       // prevent instantiation
    public static int square(int n) { return n * n; }
}

public enum Config {
    INSTANCE;                                    // singleton via enum
    private final Properties props = load();
}

Initialisation order

  1. Static fields and static initialisers — once, when the class is loaded.
  2. new ClassName(...) allocates memory and zeroes fields.
  3. Parent constructor (explicit or implicit super(...)).
  4. Instance field initialisers and instance initialiser blocks.
  5. This constructor's body.

Common mistakes

  • Forgetting to initialise final fields — compile error ("variable might not have been initialized").
  • Calling overridable methods from a constructor — subclass override runs before the subclass is fully initialised.
  • Throwing exceptions during partial construction — half-built objects can escape if the constructor stores this somewhere before completing.
  • Using this() with super() — only one is allowed, and only as the first statement.

Related

Pillar: OOP. Siblings: classes, this, super.

Related articles