Saras Growth Space

Posted on May 21

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

#lld #systemdesign #softwareengineering #codinginterview

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)

Concept	Meaning
Data Hiding	Restrict direct access to fields
Encapsulation	Bundle + control state through behavior

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.

DEV Community