Benefits of Encapsulation

Encapsulation is useful because it keeps objects valid, understandable, and easier to change.

1. Protects Object State

Private data cannot be changed directly from outside.

This prevents invalid changes like:

// employee.age = -20;
// account.balance = -5000;

2. Centralizes Validation

Rules are written in one place: inside the class.

bool setAge(int value) {
    if (value < 0 || value > 150) {
        return false;
    }

    age = value;
    return true;
}

Now every age update uses the same rule.

3. Makes Code Easier To Debug

If balance can only change through deposit() and withdraw(), bugs are easier to trace.

You know where to look.

4. Hides Implementation Details

Outside code should depend on what the object can do, not how it stores data.

Today:

double balance;

Later:

long long balanceInCents;

If the public methods stay the same, outside code does not need to change.

5. Gives Read/Write Control

You can choose:

• read-only data: provide getter only
• write-controlled data: provide validated setter
• behavior-only access: provide methods like withdraw() instead of setBalance()

Getter/Setter Warning

Encapsulation does not mean every private field needs a getter and setter.

Better:

account.withdraw(500);

Weaker:

account.setBalance(account.getBalance() - 500);

The first version keeps the rule inside the object.

Viva Answer

Encapsulation protects object state, centralizes validation, makes debugging easier, hides implementation details, and gives controlled read/write access through a public interface.

Quick Check

• How does encapsulation help debugging?
• Why is validation better inside the class?
• Why can too many getters/setters weaken design?
• How can encapsulation help when internal storage changes?