Encapsulation

Definition

Encapsulation is an object-oriented programming principle that bundles data and the methods that operate on it within a single unit (a class), while restricting direct access to the object's internal state from outside code.

Overview

Encapsulation is often summarized as 'hiding the implementation details while exposing a controlled interface.' A well-encapsulated class keeps its internal fields private and only exposes them through public methods — often getters and setters — that can validate input, enforce invariants, or trigger side effects. This means the internal representation of a class can change over time without breaking code that depends on it, as long as its public interface stays consistent. Most object-oriented languages support access modifiers like `private`, `protected`, and `public` to enforce encapsulation at the language level: private members are accessible only within the class itself, protected members are also accessible to subclasses (relevant to inheritance), and public members form the class's external contract. In languages without formal access modifiers, like early JavaScript, developers historically relied on closures to simulate private state before native private class fields were introduced. Encapsulation reduces coupling between different parts of a codebase: because other code can only interact with an object through its defined interface, that interface can be described cleanly by an interface type, and internal changes to a class's implementation don't ripple outward as long as the public contract is preserved. This is the same underlying idea that makes dependency injection and mockable, testable code possible — components interact through stable, well-defined boundaries rather than reaching into each other's internals. Good encapsulation also improves code safety by preventing external code from putting an object into an invalid state; a setter method can validate a new value before accepting it, something a raw public field can't do.

Key Concepts

• Bundles data and behavior together within a class
• Restricts direct access to internal state via access modifiers
• Exposes a controlled public interface, often via getters and setters
• Allows internal implementation to change without breaking external code
• Enforced with private/protected/public keywords in most OOP languages
• Reduces coupling between components across a codebase
• Prevents objects from being placed into invalid or inconsistent states

Use Cases

Frequently Asked Questions

Related in Programming