What is the difference between static and instance members?

Question

Accepted Answer

**Instance members** belong to each object and can differ per object. **Static (class) members** belong to the *class itself* — there is exactly one copy, shared by all instances, and you access them without creating an object.

## One copy vs. one per object

```java
public class Counter {
    static int total = 0;        // ONE shared across all instances
    int id;                      // ONE per object

Counter() {
        total++;                 // increments the shared counter
        id = total;              // unique per object
    }

static int getTotal() { return total; }   // no object needed
}

new Counter(); new Counter();
System.out.println(Counter.getTotal());  // 2 — accessed via the class
```

`total` is shared; `id` is per object. `getTotal()` is called on the class, not an instance.

## Key rules

```text
static method   → cannot use 'this' or instance fields (no object exists)
instance method → can use both static and instance members
static field    → shared mutable state → beware in concurrent code
```

## Pitfall

Static methods are convenient but **hard to mock** and create hidden global dependencies — overusing them drifts toward procedural code and hurts testability. Mutable static fields are a classic source of thread-safety bugs.

## Why it matters

Choosing static vs. instance is a design decision: static suits stateless utilities and true class-wide data, instance suits everything tied to an object's identity.

The common trap is static mutable state — it's global state in disguise, which couples code and breaks under concurrency and testing.