Encapsulation and Access Modifiers in AP CSA: Complete Guide (2025-2026)

Encapsulation is the Unit 3 principle of hiding implementation details and controlling access to data through well-defined public interfaces. It is the reason AP CSA insists that instance variables be private and that all outside interaction happens through constructors, getters, and setters. This guide covers access modifiers, why encapsulation matters, and the tricky exam scenarios students frequently miss.

What Is Encapsulation?

Encapsulation bundles data and behavior inside a class and restricts direct access to that data. The class becomes a “black box”: other code can call its public methods but cannot see or change the internal state directly. This allows the class to enforce rules (e.g., balance can never be negative) and change its internal structure without breaking external code.

Access Modifiers

• public — accessible from any class
• private — accessible only within the declaring class
• AP CSA rule: all instance variables = private; constructors and most methods = public

Code Examples

Example 1: Proper Encapsulation

public class Account {
    private double balance;
    private String owner;

    public Account(String owner, double start) {
        this.owner = owner;
        balance = (start >= 0) ? start : 0;
    }

    public double getBalance() { return balance; }
    public String getOwner()  { return owner; }

    public void deposit(double amt) {
        if (amt > 0) balance += amt;
    }

    public static void main(String[] args) {
        Account acc = new Account("Alex", 100);
        System.out.println(acc.getBalance()); // compiles
        // acc.balance = -999; // COMPILE ERROR: private
        acc.deposit(50);
        System.out.println(acc.getBalance());
    }
}

Example 2: Reference Leaking (Broken Encapsulation)

import java.util.ArrayList;
public class Roster {
    private ArrayList members = new ArrayList<>();

    public void add(String name) { members.add(name); }

    // BAD: returns actual reference
    public ArrayList getMembers() { return members; }

    public int size() { return members.size(); }

    public static void main(String[] args) {
        Roster r = new Roster();
        r.add("Alice"); r.add("Bob");
        ArrayList copy = r.getMembers(); // same ref!
        copy.clear(); // clears the internal list
        System.out.println(r.size()); // should be 2 -- is it?
    }
}

Example 3: Enforcing Invariants via Setters

public class Gradebook {
    private int score;

    public int getScore() { return score; }
    public void setScore(int s) {
        if (s >= 0 && s <= 100) score = s;
        // invalid values are simply ignored
    }

    public static void main(String[] args) {
        Gradebook gb = new Gradebook();
        gb.setScore(85);
        gb.setScore(150);  // rejected
        gb.setScore(-10);  // rejected
        System.out.println(gb.getScore());
    }
}

Common Pitfalls

Check for Understanding

public class Vault {{
    private int code;
    public int attempts;
    public Vault(int c) {{ code = c; }}
    public boolean verify(int guess) {{ return guess == code; }}
}}

public double[] getInfo() {{
    return new double[]{{ balance }};
}}

ArrayList items = obj.getItems();
items.clear();

Frequently Asked Questions

Related Topics