Encapsulation and Access Modifiers

Protecting the inside of an object

Encapsulation means bundling data with the methods that operate on it and restricting direct access to that data. The goal is to protect invariants, rules that must always hold, such as "balance is never negative" or "end date is after start date". Other code interacts only through a small public interface, so the class can change its internals later without breaking callers. Access modifiers enforce this. In Java: private (visible only inside the class), package-private (no modifier; visible within the package), protected (package plus subclasses) and public (everywhere). C++ has private, protected and public sections; C# adds internal. Python has no enforced privacy: a leading underscore (_balance) signals "internal by convention", and double underscores trigger name mangling. Make fields private by default, expose operations rather than raw setters, and add getters only for data callers genuinely need.

Public interface, private state

Callers use public methods; private fields can change only through those methods.

Operations instead of setters

There is no setBalance; the only ways to change the balance enforce the rules.

public class BankAccount {
    private final String accountNo;
    private long balancePaise;                     // private: no outside code can change it

    public BankAccount(String accountNo) {
        this.accountNo = accountNo;
    }

    public void deposit(long paise) {
        if (paise <= 0) throw new IllegalArgumentException("deposit must be positive");
        balancePaise += paise;
    }

    public boolean withdraw(long paise) {
        if (paise <= 0 || paise > balancePaise) return false;   // invariant: never negative
        balancePaise -= paise;
        return true;
    }

    public long getBalancePaise() { return balancePaise; }
    public String getAccountNo()  { return accountNo; }
}

Getters and setters are not encapsulation

A class with private fields and a public getter and setter for each one is barely different from public fields: any code can still set any value. Real encapsulation exposes meaningful operations that keep the object valid.

Quick check: Which Java access modifier makes a member visible only inside its own class?

• public
• protected
• private
• package-private (no modifier)