Instance Variables in Java — Fields

An instance variable — or field — is a variable declared inside a class body, outside any method, and without the static keyword. Each object gets its own copy of every instance field. Fields hold the object's state.

Declaration and initialisation

public class BankAccount {
    private final String owner;               // must be set in constructor
    private BigDecimal balance = BigDecimal.ZERO;  // inline initialiser

    public BankAccount(String owner) {
        this.owner = owner;
    }
}

Default values

Unlike local variables, fields have sensible defaults:

Initialisation order

1. The object is allocated; all fields set to their default.
2. Parent constructor runs (explicit or implicit super(...)).
3. Instance initialiser blocks and inline field initialisers run top-to-bottom.
4. The constructor body runs.

public class Foo {
    private int a = 1;
    { System.out.println("init block, a=" + a); }
    private int b = 2;
    public Foo() { System.out.println("ctor, b=" + b); }
}
// Output: "init block, a=1" then "ctor, b=2"

this.field vs field

public User(String name) {
    this.name = name;         // disambiguate field from parameter
}

public String description() {
    return name;              // unambiguous — no parameter shadows
}

Best practices

• Always private unless there's a reason not to.
• Prefer final — immutable fields are safer and can be safely shared across threads.
• Defensive copies — if a field is a mutable collection taken from outside, copy it: this.items = List.copyOf(items);.
• Records for data — use a record instead of a class with a long field list + constructor + getters.

Common mistakes

• Public fields — bypass encapsulation.
• Non-final fields that never change after construction — add final.
• Mutable fields in a class that appears in HashSet/HashMap keys — changing them corrupts lookups.

Related

Pillar: Variables in Java. See also static variables, encapsulation, records.