LLD Object-Oriented Design: Encapsulation (Protecting State and Behavior)

Once you understand classes and objects, the next critical step in object-oriented design is:

Controlling how internal state is accessed and modified.

This is where encapsulation becomes essential.

What is Encapsulation?

Encapsulation means:

Keeping data (state) and methods (behavior) together, while controlling direct access to internal state.

It is not just about “hiding variables”.

It is about protecting the integrity of an object.

Why Encapsulation Matters

Without encapsulation:

• any part of the system can modify state directly
• rules can be bypassed
• invalid states become possible

With encapsulation:

• object controls its own data
• rules are enforced in one place
• system becomes predictable

Bad Design: No Encapsulation

class BankAccount:
    def __init__(self, balance):
        self.balance = balance

Now anyone can do:

account.balance = -5000

This breaks business rules completely.

Good Design: Encapsulation

class BankAccount:
    def __init__(self, balance):
        self._balance = balance

    def deposit(self, amount):
        if amount <= 0:
            raise Exception("Invalid amount")
        self._balance += amount

    def get_balance(self):
        return self._balance

Now:

• state is protected
• modifications are controlled
• validation is enforced

Key Idea: Control Through Methods

Instead of allowing direct access:

You expose controlled behavior.

So instead of:

• account.balance = X

You do:

• account.deposit(X)

Encapsulation in Real Systems

Example: Order System

class Order:
    def __init__(self):
        self._status = "CREATED"

    def mark_paid(self):
        if self._status != "CREATED":
            raise Exception("Invalid transition")
        self._status = "PAID"

Here:

• status cannot be changed freely
• only valid transitions are allowed

What Encapsulation Really Protects

Encapsulation protects:

1. State Integrity

Prevents invalid data.

2. Business Rules

Ensures rules are always applied.

3. System Consistency

Keeps objects in valid states.

Encapsulation vs Data Hiding (Important Distinction)

Encapsulation is broader and more important in LLD.

Common Mistake: Getters/Setters Everywhere

Beginners often do this:

class User:
    def get_name(self):
        return self.name

    def set_name(self, name):
        self.name = name

This does NOT add real encapsulation.

Why?

• no validation
• no rules enforced
• still exposes raw state

Better Thinking

Instead of:

• “How do I expose data?”

Think:

“What operations should be allowed on this object?”

Encapsulation in System Design

In real systems:

• payment status cannot be directly modified
• order state transitions must follow rules
• account balances cannot be arbitrary

Encapsulation ensures these constraints are always enforced.

Design Principle

Objects should protect their own state and expose only meaningful behavior.

Why Encapsulation is Critical

Without it:

• systems become fragile
• bugs become unpredictable
• debugging becomes difficult

With it:

• objects become reliable units
• system behavior becomes predictable
• design becomes scalable

One-Line Takeaway

Encapsulation ensures that an object controls its own state and exposes only safe, meaningful operations.