Wanneer moet je getters en setters gebruiken (en wanneer niet)?

Question

Accepted Answer

Getters/setters geven gecontroleerde toegang tot velden, maar de gebruikelijke gewoonte om voor elk veld een te maken is een anti-pattern. De echte vraag is: voegt de accessor waarde toe, of doet het gewoon een publiek veld opnieuw beschikbaar met extra stappen?

## Waarom het belangrijk is

```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; }
}
```

Hier dwingt de setter een invariant af — dat is het waard.

## Wanneer het gewoon ruis is

```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.
```

## Een betere mentaliteit: zeg het, vraag het niet

In plaats van state bloot te stellen zodat aanroepende code het kan manipuleren, stelt u *gedrag* bloot:

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

## Waarom het belangrijk is

Een setter op elk veld is nauwelijks beter dan het veld openbaar maken — het geeft een vals gevoel van inkapseling terwijl elke aanroeper de status vrijelijk kan wijzigen.

Ontwerpen rond gedrag ("zeg het, vraag het niet") houdt invarianten binnen het object, vermindert koppeling en onthult vaak dat veel velden onveranderlijk zouden moeten zijn zonder setter.