Când ar trebui să utilizezi getteri și setteri (și când nu)?

Question

Accepted Answer

Getteri/setteri expun accesul controlat la câmpuri, dar obiceiul obișnuit de a adăuga unul *pentru fiecare câmp* este un anti-pattern. Întrebarea reală este: accesoriu adaugă valoare, sau doar re-expune un câmp public cu pași extra?

## Când un setter este justificat

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

Aici setterul impune un invariant — asta merită.

## Când sunt doar zgomot

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

## O mentalitate mai bună: spune, nu întreba

În loc să expui stare pe care apelatorii să o manipuleze, expui *comportament*:

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

## De ce conteaza

Un setter pe fiecare câmp este abia mai bun decât a face câmpul public — dă o false senzație de încapsulare în timp ce permite oricui să mute starea liber.

Proiectarea în jurul comportamentului ("spune, nu întreba") păstrează invarianți în interiorul obiectului, reduce cuplarea și deseori relevă că mulți câmpuri ar trebui să fie imuabili fără niciun setter.