What you will learn

• Write a constructor with the right name, no return type, and a full set of assignments
• Explain what Java's default constructor does, and when you stop getting it
• State the default value of an int, a double, a boolean and an object reference
• Write overloaded constructors and say what makes each signature distinct
• Spot the reversed assignment and the parameter that shadows an attribute
• Check that every overload leaves the object completely initialised

Why this matters on the exam

Constructors are the second point on free-response question 2, every year. The rubric wording varies but the check does not: the reader looks for a constructor with the correct signature that assigns every instance variable the specification describes. Miss one attribute in one overload and the point goes.

On the multiple-choice side this topic is unusually mechanical, which makes it cheap marks. A constructor with void in front of it is no longer a constructor. A constructor whose assignment runs backwards reads an uninitialised field and stores nothing useful. A parameter with the same name as an attribute shadows it, so a bare assignment writes the parameter to itself and the object never changes. Each of those has a recognisable shape, and none of them produces a compiler error.

That last part is the reason this lesson matters more than it looks. Every failure here compiles and runs. The object simply comes out wrong, and the first evidence is a value of 0 or null somewhere far away from the constructor that caused it.

The problem this solves

A game lets you start as a nameless rookie, or pick a name, or pick a name and a starting level. Three ways in, one object at the end, and every one of them has to leave a character the rest of the game can handle. That is what overloaded constructors are for. The trap is that Java will happily build a half-initialized object for you: a field you forgot is not an error, it is a 0, a false, or a null, and it will not surface until something downstream behaves strangely.

Constructors: the only moment an object is born

A constructor runs exactly once per object, at new, and its whole job is to leave the object in a valid starting state. It has the same name as the class, it is always public, and it has no return type at all, not even void. Writing one is how you make sure an object never exists in a state your methods cannot handle.

The shape, and the one that appears for free

public class GameCharacter {
    private String name;
    private int level;

    // same name as the class, no return type
    public GameCharacter(String n, int lvl) {
        name = n;
        level = lvl;
    }
}

// write NO constructor and Java supplies
// a no-argument one that sets nothing.
// write ANY constructor and that free
// one disappears.

Overloading: several ways to be born

Two constructors can share a name because they differ in their signature, which is the ordered list of parameter types. Java picks the one whose signature matches the arguments at the call.

public GameCharacter() {
    name = "Rookie";
    level = 1;
}

public GameCharacter(String n) {
    name = n;
    level = 1;
}

public GameCharacter(String n, int lvl) {
    name = n;
    level = lvl;
}

What you do not set, Java sets for you

An instance variable the constructor never assigns is not garbage and it is not an error. It quietly takes its type's default.

private int count;      // 0
private double rate;   // 0.0
private boolean open; // false
private String label; // null

Vocabulary

Predict first, then check

Common misconceptions

Each of these is a real answer students give. Read the wrong version first and decide why it is wrong before you read the fix.

See three constructors run

The same class, built three different ways. Watch which overload runs, what each one sets, and what a field that nobody assigns quietly becomes.

Live code editor

Eight problems, six scaffolded and two open-ended. Write Java and press Run to execute it. When you are ready, press Submit to test it against the expected output; the reference solution then appears underneath, next to your own code rather than on top of it. Hints are there if you are stuck, and attempts and hints are both tracked.

Constructor Arcade

Six quick rounds. Read the class and the client code, then type the final value. These are the six constructor traps the exam keeps returning to: which overload runs, what a forgotten field defaults to, and what the order of the lines does to a derived value.

public class A {
    private int n;
    public A() { n = 5; }
    public A(int v) { n = v; }
    public int get() { return n; }
}
A a = new A();
int x = a.get();

public class B {
    private int n;
    private int twice;
    public B(int v) { n = v; twice = n * 2; }
    public int get() { return twice; }
}
B b = new B(9);
int x = b.get();

public class C {
    private int n;
    private int twice;
    public C(int v) { twice = n * 2; n = v; }
    public int get() { return twice; }
}
C c = new C(9);
int x = c.get();

public class D {
    private int health;
    public D(int lvl) { health = 100 + 10 * (lvl - 1); }
    public int get() { return health; }
}
D d = new D(6);
int x = d.get();

public class E {
    private int a;
    private int b;
    public E() { a = 3; b = 4; }
    public E(int v) { a = v; }
    public int get() { return a + b; }
}
E e = new E(10);
int x = e.get();

public class F {
    private int side;
    private int area;
    public F() { side = 1; area = 1; }
    public F(int s) { side = s; area = s * s; }
    public F(int w, int h) { side = w; area = w * h; }
    public int get() { return area; }
}
F f = new F(3, 8);
int x = f.get();

Multiple choice

Predict your answer before reading the options. Watch for the qualifier words. After you answer, the rationale explains every distractor.

public class Crate {
    private int items;
    private int capacity;
    private int spare;

    public Crate(int c) {
        capacity = c;
        spare = capacity - items;
    }

    public int getSpare() {
        return spare;
    }
}

Crate c = new Crate(12);
System.out.println(c.getSpare());

public class Stopwatch {
    private int seconds;
    private boolean running;

    public Stopwatch() {
        seconds = 60;
        running = true;
    }

    public Stopwatch(int s) {
        seconds = s;
    }
}

public class Badge {
    private String owner;
    private int level;

    public Badge(String o) {
        owner = o;
        level = 1;
    }

    public String getOwner() { return owner; }
    public int getLevel() { return level; }
}

I.   new Badge("Ana") creates a Badge with level 1
II.  Badge declares exactly one constructor
III. new Badge() compiles and creates a Badge with owner null

public class Sample {
    // constructors go here
}

public class Bin {
    private int capacity;
    private int count;
    // constructors go here
}

public class Sample {
    private int mass;

    public Sample(int mass) {
        mass = mass;
    }

    public int getMass() {
        return mass;
    }
}

public class Tile {
    private int size;
    private boolean placed;
    private String label;

    public int getSize() {
        return size;
    }

    public boolean isPlaced() {
        return placed;
    }

    public String getLabel() {
        return label;
    }
}

Tile t = new Tile();
System.out.println(t.getSize());
System.out.println(t.isPlaced());
System.out.println(t.getLabel());

I.   new Crate(2, 3)
II.  new Crate(4)
III. new Crate()

public class Pack {
    // which pair cannot coexist?
}

public class Bin {
    private int capacity;

    public Bin(int cap) {
        cap = capacity;
    }

    public int getCapacity() {
        return capacity;
    }
}

public class Order {
    private int total;

    public Order() { ... }
    public Order(int n) { ... }
    public Order(int n, int rate) { ... }
}

public class Pack {
    private int size;
    private int weight;

    public Pack() {
        size = 2;
        weight = 10;
    }

    public Pack(int s) {
        size = s;
        weight = size * 5;
    }

    public int total() {
        return size + weight;
    }
}

Pack p = new Pack(4);
Pack q = new Pack();
System.out.println(p.total() + q.total());

FRQ Practice

Free-response question 2 is Class Design, and constructors are where most of its second point lives. A reader is checking one thing above all: does every constructor leave the object completely set up? An overload that forgets one attribute produces an object that is legal, compiles, and is quietly wrong.

This one is worth 4 points. The three constructors are yours to write; the method headers are given, because writing methods from nothing is 3.5. Route all three through the private helper rather than repeating the pricing rule, which is the same instinct as 3.3's clamp helper.

A streaming service sells three plans by the month, with a discount for a year or more.

Scoring: 1 point for three constructors with distinct parameter lists, 1 point for all three leaving every attribute set, 1 point for the pricing including the unknown-plan fallback, and 1 point for the discount applying at exactly 12 months and not at 11.

Choose your lane

Summary

A constructor is the method that runs when an object is created. It carries the class's name, takes no return type, and is always public in this course. Its single responsibility is that the object is completely set up by the time new hands it back.

If a class declares no constructor at all, Java supplies a default constructor that takes no arguments and leaves every attribute at its default: 0 for numeric types, false for boolean, and null for any object reference. Declaring even one constructor removes that free one, which is why a specification describing three ways to build an object needs three written constructors.

Several constructors can share the name as long as their parameter lists differ - overloading - and the compiler picks by the arguments at the call site. The failure that costs points is an overload that initialises only some attributes, because the resulting object is legal and quietly wrong. Two smaller traps have the same character: an assignment written backwards, and a parameter named the same as the attribute it was meant to fill. Neither is a compiler error. Both leave a default value where a real one should be.

Frequently asked questions

Related lessons

Unit 3: Class Creation

All 9 lessons in this unit. You are on 3.4.

1. 3.1 Abstraction and Program Design
2. 3.2 Impact of Program Design
3. 3.3 Anatomy of a Class
4. 3.4 Constructors
5. 3.5 Methods: How to Write Them
6. 3.6 Methods: Passing and Returning Object References
7. 3.7 Class Variables and Methods
8. 3.8 Scope and Access
9. 3.9 The this Keyword

Test yourself on this unit

The rest of the course