Encapsulation అంటే ఏమిటి?

Question

Accepted Answer

**Encapsulation** అంటే డేటా మరియు దానిపై పనిచేసే పద్ధతులను ఒక యూనిట్ (క్లాస్) లో కట్టిపడుతూ **అంతర్గత స్థితిని** నియంత్రిత ప్రజా ఇంటర్ఫేస్ వెనుక దాచడం. కాలర్లు ఫీల్డ్‌ను నేరుగా యాక్సెస్ చేయకుండా పద్ధతుల ద్వారా ఇంటరాక్ట్ చేస్తారు.

## స్థితి ఎందుకు దాచాలి

ఎవరైనా ఫీల్డ్‌ను నేరుగా మార్చగలిగితే, వస్తువు ఎల్లప్పుడూ చెల్లుబాటు అయ్యే నిర్ధారణ చేయలేరు. Encapsulation క్లాస్‌ను **దాని స్వంత అనిర్వచనీయ సూత్రాలను ఉపయోగించుకోమని** అనుమతిస్తుంది.

```java
public class Account {
    private double balance;             // hidden: no direct access

public void withdraw(double amount) {
        if (amount <= 0)                // guard the invariant
            throw new IllegalArgumentException("amount must be positive");
        if (amount > balance)
            throw new IllegalStateException("insufficient funds");
        balance -= amount;              // only valid changes get through
    }

public double getBalance() { return balance; }
}
```

```java
// Without encapsulation, this would be possible and disastrous:
account.balance = -5000;   // bypasses every rule
```
`balance` ప్రైవేట్ ఎందుకంటే, దానిని మార్చడానికి *ఏకైక* మార్గం `withdraw` ద్వారా వెళుతుంది, ఇది నియమాలను రక్షిస్తుంది.

## ప్రమాదం

Encapsulation అంటే "ప్రతి ఫీల్డ్ కోసం getter/setter జోడించండి" కాదు. ప్రతిదానికీ setter ని బహిర్గతం చేయడం ప్రజా ఫీల్డ్‌ల కంటే కొద్దిగా బాగుంది. *ప్రవర్తన*, ఎటువంటి స్థితి ను బహిర్గతం చేయండి.

## ఇది ఎందుకు ముఖ్యమైనది

Encapsulation ఒక సమయంలో అనిర్వచనీయ సూత్రాలను ఉంచుతుంది, కాబట్టి బ్యాలెన్స్ హ్యాండ్లింగ్‌లో ఏదైనా బగ్ `Account` లో మాత్రమే ఉండగలదు, కోడ్‌బేస్ నలుమూ ఉండకుండా చేస్తుంది.

ఇది అంతర్గత ప్రతినిధిత్వం (సెంట్లను పూర్ణాంకం వలె సంచయం, లాగింగ్ జోడించు) తరువాత కూడా మార్చడానికి మిమ్మల్ని అనుమతిస్తుంది కాలర్‌లను విచ్ఛిన్నం చేయకుండా, ఎందుకంటే అవి ప్రజా ఇంటర్ఫేస్‌పై మాత్రమే ఆధారపడి ఉంటాయి.