Når bør du bruke getters og setters (og når ikke)?

Question

Accepted Answer

Getters/setters gir kontrollert tilgang til felt, men den vanlige vanen med å legge til en *for hvert felt* er et anti-pattern. Det egentlige spørsmålet er: legger accessoren til verdi, eller gjeneksponerer den bare et offentlig felt med ekstra trinn?

## Når en setter er berettiget

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

Her håndhever settere en invariant — det er det verd.

## Når de bare er støy

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

## En bedre mentalitet: fortell, ikke spør

I stedet for å eksponere tilstand for som kallerene kan manipulere, eksponerer du *atferd*:

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

## Hvorfor det betyr noe

En setter på hvert felt er knapt bedre enn å gjøre feltet offentlig — det gir en falsk følelse av innkapsling mens enhver anropende part kan mutere tilstand fritt.

Design omkring atferd ("fortell, ikke spør") holder invarianter inne i objektet, reduserer kobling, og avslører ofte at mange felt bør være uforanderlige uten setter i det hele tatt.