What is Encapsulation?

Encapsulation is the OOP principle of bundling data (attributes) and the methods that operate on that data into a single unit (class), while restricting direct external access to the internal state. It is one of the four fundamental pillars of OOP alongside Abstraction, Inheritance, and Polymorphism.

Explanation

Real-World Analogy

Think of a capsule pill 💊 — the medicine inside is fully protected by the outer shell. You don’t pour chemicals directly into your body; you take the capsule which controls how and when the medicine is released.
Similarly, a class is the “capsule” — it protects its internal data and only exposes controlled access through public methods.

Real World	OOP Equivalent
Capsule shell	Class boundary
Medicine inside	Private attributes
How you consume it	Public methods (API)
“Don’t open the capsule”	Private / protected access

Another analogy: A TV remote 📺 — you press buttons (public methods). You cannot reach inside and rewire the circuit (private internals).

Why Encapsulation Matters

Without encapsulation, any code anywhere could directly modify an object’s data, causing unpredictable bugs.

WITHOUT Encapsulation:              WITH Encapsulation:

user.age = -999  # 💀 valid!        user.set_age(-999)  # ❌ raises error
user.balance = 0 # 💀 instant loss  user.withdraw(...)  # ✅ validated

Benefit	Description
Data Protection	Prevent invalid/corrupt state from being set directly
Controlled Access	Define exactly what callers can read or write
Flexibility	Change internal implementation without breaking callers
Maintainability	Isolate changes — fix one place, not everywhere
Testability	Mock public interfaces; internals stay hidden

Access Modifiers

Access modifiers are the mechanism that enforces encapsulation. They control who can see an attribute or method.

Modifier	Python Syntax	Java / C# / C++	Accessible From
Public	`self.name`	`public`	Anywhere — inside class, subclass, outside
Protected	`self._name` (convention)	`protected`	Inside class + all subclasses
Private	`self.__name` (name mangling)	`private`	Only inside the class itself

flowchart LR
    EXT["🌍 External Code"] -->|"✅ Can access"| PUB["Public\nself.name"]
    EXT -->|"⚠️ Should not"| PRO["Protected\nself._name"]
    EXT -->|"❌ Cannot"| PRI["Private\nself.__name"]
    SUB["👶 Subclass"] -->|"✅ Can access"| PUB
    SUB -->|"✅ Can access"| PRO
    SUB -->|"❌ Cannot"| PRI
    CLS["🏠 Same Class"] -->|"✅ Can access"| PUB
    CLS -->|"✅ Can access"| PRO
    CLS -->|"✅ Can access"| PRI

In Python, access control is by convention, not enforced by the interpreter. self.__name becomes self._ClassName__name via name mangling — still accessible but clearly marked private. Java/C++ enforce it at compile time.

Getters & Setters

When attributes are private, you provide getter (read) and setter (write) methods to control access safely.

Method Type	Purpose	Validates?
Getter	Returns the value of a private attribute	No (read-only)
Setter	Sets a new value with validation logic	Yes (enforces rules)
Property	Python/C# syntax sugar — looks like attribute, acts like getter/setter	Yes

┌───────────────────────────────────────────────┐
│             CLASS: Person                     │
│ ─────────────────────────────────────────     │
│  PRIVATE:  __age  (int)                       │
│                                               │
│  PUBLIC getter: get_age()  → returns __age    │
│  PUBLIC setter: set_age(v) → validates + sets │
│                                               │
│  External code: person.set_age(25)  ✅        │
│  External code: person.__age = 25   ❌        │
└───────────────────────────────────────────────┘

Implementation

Full encapsulation example — a Person class with private attributes, validated setters, Python properties, and equivalent in all 5 languages. Languages: Python · Cpp · Java · Java Script · CSharp

# ─── Python ──────────────────────────────────────────────────────────
class Person:
    def __init__(self, name: str, age: int):
        self.name = name          # public
        self._species = "Human"   # protected (convention)
        self.__age = age          # private (name-mangled to _Person__age)
        self.__validate_age(age)
 
    # ── Private helper ────────────────────────────────
    def __validate_age(self, age: int):
        if not isinstance(age, int) or age < 0 or age > 150:
            raise ValueError(f"Invalid age: {age}")
 
    # ── Getter via @property ──────────────────────────
    @property
    def age(self) -> int:
        return self.__age
 
    # ── Setter via @age.setter ────────────────────────
    @age.setter
    def age(self, value: int):
        self.__validate_age(value)
        self.__age = value
 
    # ── Read-only property (no setter) ────────────────
    @property
    def info(self) -> str:
        return f"{self.name}, Age: {self.__age}"
 
    def __str__(self):
        return self.info
 
 
p = Person("Alice", 30)
print(p.age)          # 30   — via getter
p.age = 31            # ✅   — via setter
print(p)              # Alice, Age: 31
 
# p.__age = 999       # ❌ Won't modify the real __age
# p.age = -5          # ❌ raises ValueError: Invalid age: -5
 
# Name mangling — still accessible but clearly private:
print(p._Person__age) # 31 (name-mangled, discouraged to use)

// ─── C++ ─────────────────────────────────────────────────────────────
#include <iostream>
#include <string>
#include <stdexcept>
 
class Person {
private:
    std::string name_;
    int age_;
 
    void validateAge(int age) const {
        if (age < 0 || age > 150)
            throw std::invalid_argument("Invalid age: " + std::to_string(age));
    }
 
protected:
    std::string species = "Human";
 
public:
    Person(const std::string& name, int age)
        : name_(name), age_(age) {
        validateAge(age);
    }
 
    // ── Getter ────────────────────────────────────────
    int getAge() const { return age_; }
    std::string getName() const { return name_; }
 
    // ── Setter ────────────────────────────────────────
    void setAge(int age) {
        validateAge(age);
        age_ = age;
    }
    void setName(const std::string& name) { name_ = name; }
 
    std::string info() const {
        return name_ + ", Age: " + std::to_string(age_);
    }
 
    friend std::ostream& operator<<(std::ostream& os, const Person& p) {
        return os << p.info();
    }
};
 
int main() {
    Person p("Alice", 30);
    std::cout << p.getAge() << "\n";  // 30
    p.setAge(31);                     // ✅ validated setter
    std::cout << p << "\n";           // Alice, Age: 31
    // p.age_ = 999;                  // ❌ compile error — private
    // p.setAge(-5);                  // ❌ throws invalid_argument
}

// ─── Java ─────────────────────────────────────────────────────────────
public class Person {
    // Private fields — not accessible outside
    private String name;
    private int age;
 
    // Protected field — accessible in subclasses
    protected String species = "Human";
 
    public Person(String name, int age) {
        this.name = name;
        setAge(age);  // Use setter for validation even in constructor
    }
 
    // ── Getter ────────────────────────────────────────
    public int getAge() { return age; }
    public String getName() { return name; }
 
    // ── Setter with validation ─────────────────────────
    public void setAge(int age) {
        if (age < 0 || age > 150)
            throw new IllegalArgumentException("Invalid age: " + age);
        this.age = age;
    }
    public void setName(String name) { this.name = name; }
 
    public String info() {
        return name + ", Age: " + age;
    }
 
    @Override
    public String toString() { return info(); }
 
    public static void main(String[] args) {
        Person p = new Person("Alice", 30);
        System.out.println(p.getAge());  // 30
        p.setAge(31);                    // ✅
        System.out.println(p);           // Alice, Age: 31
        // p.age = 999;                  // ❌ compile error — private
    }
}

// ─── JavaScript (ES2022 Private Fields) ──────────────────────────────
class Person {
    // Private fields (#)
    #name;
    #age;
 
    // Protected-style (convention only — JS has no protected)
    _species = "Human";
 
    constructor(name, age) {
        this.#name = name;
        this.age = age; // goes through setter
    }
 
    // ── Getter ────────────────────────────────────────
    get age() { return this.#age; }
    get name() { return this.#name; }
 
    // ── Setter with validation ────────────────────────
    set age(value) {
        if (typeof value !== 'number' || value < 0 || value > 150)
            throw new Error(`Invalid age: ${value}`);
        this.#age = value;
    }
    set name(value) { this.#name = value; }
 
    get info() { return `${this.#name}, Age: ${this.#age}`; }
    toString() { return this.info; }
}
 
const p = new Person("Alice", 30);
console.log(p.age);        // 30  — via getter
p.age = 31;                // ✅  — via setter
console.log(p.toString()); // Alice, Age: 31
// p.#age = 999;           // ❌ SyntaxError — truly private
// p.age = -5;             // ❌ Error: Invalid age: -5

// ─── C# ──────────────────────────────────────────────────────────────
using System;
 
public class Person {
    // Private backing fields
    private string name;
    private int age;
 
    // Protected field
    protected string Species { get; } = "Human";
 
    public Person(string name, int age) {
        this.name = name;
        Age = age; // Uses property setter
    }
 
    // ── Auto property (public read, private write) ─────
    public string Name {
        get => name;
        set => name = value;
    }
 
    // ── Property with validation ───────────────────────
    public int Age {
        get => age;
        set {
            if (value < 0 || value > 150)
                throw new ArgumentException($"Invalid age: {value}");
            age = value;
        }
    }
 
    // ── Read-only computed property ────────────────────
    public string Info => $"{Name}, Age: {Age}";
 
    public override string ToString() => Info;
 
    public static void Main(string[] args) {
        var p = new Person("Alice", 30);
        Console.WriteLine(p.Age);   // 30
        p.Age = 31;                  // ✅
        Console.WriteLine(p);        // Alice, Age: 31
        // p.age = 999;             // ❌ compile error — private
    }
}

Encapsulation vs Abstraction

These two are closely linked but serve different purposes:

Concept	What it does	Focus level	How achieved
Encapsulation	Bundles data + methods, restricts direct access	Implementation level	`private`/`protected` + getters/setters
Abstraction	Hides complex logic, exposes only essentials	Design level	Abstract classes, interfaces, method naming

Encapsulation = “I will protect my data.”
Abstraction = “I will only show you what you need to know.”
Encapsulation is how you implement abstraction — they work together, not against each other.

When to Use Encapsulation

flowchart TD
    Q{"Does your class hold\ndata that can become invalid?"}
    Q -- Yes --> R1["✅ Make attributes private\nAdd validated setters"]
    Q -- No --> Q2{"Is the data read by\nmany external callers?"}
    Q2 -- Yes --> R2["✅ Use public getter\nKeep setter restricted"]
    Q2 -- No --> R3["⚠️ Consider @dataclass or struct\n(No encapsulation needed)"]

✅ Apply Encapsulation When

Internal state can become invalid if set freely (age, balance, health points).
You want to change internal representation without breaking callers.
The class will be used by others (library, API, team code).
You need computed properties that derive from private data.

❌ Skip It When

Simple data containers (DTOs, Config structs) where all fields are valid by design.
One-off scripts where the overhead of getters/setters adds no value.

Key Takeaways

Bundle data and methods into one class — the capsule.
Restrict direct access to internal state via private / protected.
Expose controlled access through getters, setters, and properties.
Python enforces this by convention (_ protected, __ private via name mangling).
Java/C++/C# enforce it at compile time — true access restriction.
Works hand-in-hand with Abstraction — encapsulation hides data, abstraction hides complexity.

Table of Contents

Explorer

Encapsulation

Explanation

Real-World Analogy

Why Encapsulation Matters

Access Modifiers

Getters & Setters

Implementation

Encapsulation vs Abstraction

When to Use Encapsulation

✅ Apply Encapsulation When

❌ Skip It When

Key Takeaways

More Learn

GitHub & Webs

Enjoying the Notes?

Graph View

Backlinks

Recently Updated