När bör du använda getters och setters (och när inte)?

Question

Accepted Answer

Getters/setters exponerar kontrollerad åtkomst till fält, men den vanliga vanan att lägga till en *för varje fält* är ett anti-mönster. Den riktiga frågan är: lägger accessorn till värde, eller exponerar den bara ett offentligt fält med extra steg?

## När en setter är motiverad

```java
public class Thermostat {
    private int target;
    public void setTarget(int t) {     // setter adds VALIDATION
        if (t < 5 || t > 30)
            throw new IllegalArgumentException("out of range");
        this.target = t;
    }
    public int getTarget() { return target; }
}
```

Här tillämpar settaren en invariant — det är värt det.

## När de bara är brus

```java
// Anti-pattern: "encapsulation theatre"
public class Point {
    private int x, y;
    public int getX() { return x; }    public void setX(int x){ this.x=x; }
    public int getY() { return y; }    public void setY(int y){ this.y=y; }
}
// This is no safer than public fields — and now x,y can change anytime.
```

## Ett bättre sätt att tänka: berätta, fråga inte

I stället för att exponera tillstånd för anropare att manipulera, exponera *beteende*:

```java
account.withdraw(100);          // ✅ behavior protects the rule
// vs
account.setBalance(account.getBalance() - 100);  // ❌ logic leaks to caller
```

## Varför det är viktigt

En setter på varje fält är knappast bättre än att göra fältet offentligt — det ger en falsk känsla av inkapsling medan det tillåter vilken anropare som helst att fritt muttera tillståndet.

Design kring beteende ("berätta, fråga inte") håller invarianter inne i objektet, minskar koppling och avslöjar ofta att många fält bör vara oföränderliga utan setter alls.