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 ஐ பொருளுக்குள் வைத்திருக்கிறது, coupling ஐ குறைக்கிறது மற்றும் பெரும்பாலும் பல புலங்களை setter இல்லாமல் மாற்றாத வேண்டும் என்பதை வெளிப்படுத்துகிறது.