ਤੁਹਾਨੂੰ getters ਅਤੇ setters ਕਦੋਂ ਵਰਤਣੇ ਚਾਹੀਦੇ ਹਨ (ਅਤੇ ਕਦੋਂ ਨਹੀਂ)?

Question

Accepted Answer

Getters/setters ਖੇਤਾਂ ਤੱਕ ਨਿਯੰਤ੍ਰਿਤ ਪਹੁੰਚ ਨੂੰ ਜਾਹਰ ਕਰਦੇ ਹਨ, ਪਰ ਹਰੇਕ ਖੇਤ ਲਈ ਇੱਕ ਜੋੜਾ ਜੋੜਨ ਦੀ ਆਮ ਆਦਤ ਇੱਕ anti-pattern ਹੈ। ਅਸਲ ਸਵਾਲ ਹੈ: ਕੀ accessor ਮੁੱਲ ਜੋੜਦਾ ਹੈ, ਜਾਂ ਸਿਰਫ਼ ਇੱਕ ਜਨਤਕ ਖੇਤ ਨੂੰ ਵਾਧੂ ਪੜਾਵਾਂ ਦੇ ਨਾਲ ਦੁਬਾਰਾ ਜਾਹਰ ਕਰਦਾ ਹੈ?

## ਜਦੋਂ setter ਜਾਇਜ਼ ਹੈ

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

ਇੱਥੇ setter ਇੱਕ invariant ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ — ਇਹ ਇਸ ਦੇ ਭਾਰ ਦੇ ਲਾਇਕ ਹੈ।

## ਜਦੋਂ ਇਹ ਸਿਰਫ਼ ਸ਼ੋਰ ਹੈ

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

## ਇੱਕ ਬਿਹਤਰ ਮਾਨਸਿਕਤਾ: ਦੱਸੋ, ਪੁੱਛੋ ਨਹੀਂ

ਸੱਦਿਆਂ ਕਨੂੰ ਹੇਰਾਫੇਰੀ ਕਰਨ ਲਈ ਸਥਿਤਿ ਨੂੰ ਜਾਹਰ ਕਰਨ ਦੀ ਬਜਾਏ, *ਵਿਵਹਾਰ* ਨੂੰ ਜਾਹਰ ਕਰੋ:

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

## ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

ਹਰੇਕ ਖੇਤ ਤੇ ਇੱਕ setter ਲਗਭਗ ਖੇਤ ਨੂੰ ਜਨਤਕ ਬਣਾਉਣ ਨਾਲੋਂ ਬਿਹਤਰ ਹੈ — ਇਹ encapsulation ਦੀ ਝੂਠੀ ਭਾਵਨਾ ਦਿੰਦਾ ਹੈ ਜਦੋਂ ਕਿ ਕੋਈ ਵੀ ਸੱਦਾ ਦੇਣ ਵਾਲਾ ਸਥਿਤਿ ਨੂੰ ਅਜ਼ਾਦ ਰੂਪ ਤੋਂ ਬਦਲ ਸਕਦਾ ਹੈ।

ਵਿਵਹਾਰ ਦੇ ਦੁਆਲੇ ਡਿਜ਼ਾਇਨ ਕਰਨਾ ("ਦੱਸੋ, ਪੁੱਛੋ ਨਹੀਂ") invariants ਨੂੰ ਆਬਜੈਕਟ ਦੇ ਅਨਦਰ ਰੱਖਦਾ ਹੈ, ਕਪਲਿੰਗ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ, ਅਤੇ ਅਕਸਰ ਇਹ ਪ੍ਰਕਾਸ਼ ਕਰਦਾ ਹੈ ਕਿ ਬਹੁਤ ਸਾਰੀਆਂ ਖੇਤਾਂ ਨੂੰ setter ਦੇ ਬਿਨਾਂ ਬਿਨਾ ਬਦਲਿਆ ਜਾ ਸਕਣਾ ਚਾਹੀਦਾ ਹੈ।