What is encapsulation?

Question

Accepted Answer

**Encapsulation** means bundling data and the methods that operate on it inside one unit (a class) and **hiding the internal state** behind a controlled public interface. Callers interact through methods, not by poking at raw fields.

## Why hide state

If anyone can change a field directly, you can never guarantee the object stays valid. Encapsulation lets the class **enforce its own invariants**.

```java
public class Account {
    private double balance;             // hidden: no direct access

public void withdraw(double amount) {
        if (amount <= 0)                // guard the invariant
            throw new IllegalArgumentException("amount must be positive");
        if (amount > balance)
            throw new IllegalStateException("insufficient funds");
        balance -= amount;              // only valid changes get through
    }

public double getBalance() { return balance; }
}
```

```java
// Without encapsulation, this would be possible and disastrous:
account.balance = -5000;   // bypasses every rule
```

Because `balance` is private, the *only* path to change it runs through `withdraw`, which protects the rules.

## Pitfall

Encapsulation is not "add a getter/setter for every field." Exposing a setter for everything is barely better than public fields. Expose *behavior*, not raw state.

## Why it matters

Encapsulation keeps invariants in one place, so a bug in balance handling can only live inside `Account`, not scattered across the codebase.

It also lets you change the internal representation later (store cents as an integer, add logging) without breaking callers, because they only depend on the public interface.