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` உள்ளே மட்டுமே வாழ முடியும், குறியீடு முழுவதும் பிரவேசம் செய்யாது।

இது பின்னர் உள் பிரதிநிதித்வத்தை மாற்ற அனுமதிக்கிறது (செண்ட்களை ஒரு முழு எண்ணாக சேமிக்கவும், பதிவு சேர்க்கவும்) அழைப்பாளர்களை உடைக்காமல், ஏனெனில் அவர்கள் பொது இடைமுகத்தை மட்டுமே சார்ந்துள்ளனர்.