Encapsulation and Access Modifiers in Java (private, protected, public, default)

Encapsulation is about controlling the surface area of change — not just hiding fields. Every public method or field is a dependency: the wider you expose internals, the more places break when those internals change.

What encapsulation actually means

• Private fields plus getters/setters is indirection, not encapsulation — account.setBalance(account.getBalance() - 100) puts all the logic on the caller, with no validation, no overdraft check, no audit log
• Real encapsulation exposes behavior, not state: account.withdraw(100) keeps all of that inside the class
• Change balance from double to BigDecimal with real encapsulation — no callers notice, because they called withdraw(), never getBalance()

The four access modifiers

• private — class only; no modifier (package-private) — same package; protected — same package plus subclasses in other packages; public — everyone, permanently
• Interview trap: protected ≠ only subclasses — it includes the entire same package, making it strictly wider than package-private
• There is no default keyword — you omit the modifier. default int count is a syntax error.

When to reach for each

• Start private — widen only when there's a concrete reason
• Package-private (no modifier): internal classes the same package needs but nothing outside should touch
• Every public method is a permanent API contract — once external code depends on it, removing it is a breaking change

Lombok's @Setter on every field undoes this entirely. If a field needs to change, there should be a method that describes why — not a setter that just sets.