What you will learn

• Name the four parts of a class and say what each one is for
• Write an accessor that reports a value without changing anything
• Write a mutator that enforces the class's rule before it stores anything
• Choose public or private for data, constructors and methods, and defend the choice
• Explain why a public instance variable makes a class unable to keep its own guarantee
• Spot the four accessor and mutator errors the exam reaches for again and again

Why this matters on the exam

Lesson 3.3 is where Unit 3 stops being about diagrams and starts being about Java. Under the 2025 CED the learning objective is stated as developing code to designate access and visibility constraints on classes, data, constructors and methods, and the essential knowledge is unusually prescriptive: in this course classes are always public, constructors are always public, and instance variables are private unless the specification says otherwise.

That prescriptiveness is a gift on the exam. It means a multiple-choice question can show you a class and expect you to say what is wrong with it in seconds, and it means free-response question 2 opens with a point you can bank: the class header and the private instance variables. Readers give that point for declaring the attributes at the right access level, before any logic is judged at all.

The errors that cost points here are small and repetitive. An accessor that quietly changes state. A getter whose return type does not match the field. A setter written to return something. Code that reaches for a private field from outside the class and does not compile. Learn those four shapes and a whole family of questions collapses into recognition.

The problem this solves

The CED asks it directly: how can a program be written to protect your account balance from being changed by accident? Leave the balance out in the open and any line of code anywhere can set it to a negative number, and nothing in the language will stop it. Put a wall around it, leave one door, and put the rule in the doorway, and the impossible state simply cannot happen. That wall is private, the door is a public method, and the pair of them is what the exam means by encapsulation.

The anatomy of a class, and the wall around it

A class has four parts and one job. The parts are the header, the instance variables, the constructors, and the methods. The job is to protect its own data, so that no code outside it can put the object into a state that should be impossible.

The four parts, in order

// 1. header: always public, keyword class
public class LunchAccount {

    // 2. instance variables: private
    private int balance;

    // 3. constructor: always public
    public LunchAccount(int startCents) {
        balance = startCents;
    }

    // 4. methods: public interface,
    //    private helpers
    public int getBalance() {
        return balance;
    }
}

Those first three are not style opinions. In this course they are the rule: classes are public, constructors are public, and instance variables are private unless a specification says otherwise.

What public and private actually mean

// inside the class: everything is reachable
public boolean buy(int cents) {
    if (!canAfford(cents)) { return false; }
    balance -= cents;      // private field: fine
    return true;
}

private boolean canAfford(int cents) {
    return cents > 0 && cents <= balance;
}

// outside the class:
acct.buy(300);       // public: allowed
acct.balance = -500;  // private: refused
acct.canAfford(1);   // private: refused

Why bother: the rule you can enforce

Make balance public and any line of code anywhere can write acct.balance = -500;. Nothing stops it. Make it private and the only road in is deposit, which you wrote, which can refuse.

// public data: no rule survives
acct.balance = -500;   // nothing stops this

// private data + a method you control
public void deposit(int cents) {
    if (cents <= 0) { return; }
    balance += cents;
}
acct.deposit(-500);    // ignored, balance safe

One copy per object

Every object built from the class carries its own instance variables. Two accounts have two balances. Changing one leaves the other alone. The wall is per class, but the data is per object.

Vocabulary

Predict first, then check

Common misconceptions

Each of these is a real answer students give. Read the wrong version first and decide why it is wrong before you read the fix.

See the wall in memory

Two LunchAccount objects, each with its own private balance. Watch a deposit land, an invalid deposit get refused by the method, and a purchase that cannot be afforded change nothing at all.

Live code editor

Eight problems, six scaffolded and two open-ended. Write Java and press Run to execute it. When you are ready, press Submit to test it against the expected output; the reference solution then appears underneath, next to your own code rather than on top of it. Hints are there if you are stuck, and attempts and hints are both tracked.

Encapsulation Arcade

Six quick rounds. Read the class and the client code, then type the final value. These are the six ways an encapsulation question goes wrong on the exam: a missing guard, a boundary, a private helper, separate copies, a self-assigning constructor, and a method that refuses.

public class A {
    private int bal;
    public A(int start) { bal = start; }
    public void add(int n) { if (n <= 0) { return; } bal += n; }
    public int get() { return bal; }
}
A a = new A(700);
a.add(150);
a.add(-200);
int x = a.get();

public class B {
    private int bal;
    public B(int start) { bal = start; }
    private boolean ok(int n) { return n > 0 && n <= bal; }
    public boolean buy(int n) { if (!ok(n)) { return false; } bal -= n; return true; }
    public int get() { return bal; }
}
B b = new B(300);
b.buy(180);
int x = b.get();

public class C {
    private int n;
    public C(int start) { n = start; }
    public int get() { return n; }
}
C p = new C(7);
C q = new C(2);
int x = p.get() + q.get();

public class D {
    private int w;
    public D(int w) { w = w; }
    public int get() { return w; }
}
D d = new D(9);
int x = d.get();

public class E {
    private int v;
    public E(int start) { v = start; }
    private int clamp(int n) { if (n > 100) { return 100; } if (n < 0) { return 0; } return n; }
    public void set(int n) { v = clamp(n); }
    public int get() { return v; }
}
E e = new E(50);
e.set(150);
int x = e.get();

public class F {
    private int s;
    private int used;
    public F(int start) { s = start; used = 0; }
    public boolean take(int n) { if (n > s) { return false; } s -= n; used++; return true; }
    public int getUsed() { return used; }
}
F f = new F(10);
f.take(4);
f.take(20);
f.take(6);
int x = f.getUsed();

Multiple choice

Predict your answer before reading the options. Watch for the qualifier words. After you answer, the rationale explains every distractor.

public class Jar {
    private int count;

    public Jar(int start) {
        count = start;
    }

    private boolean canTake(int n) {
        return n > 0 && n <= count;
    }

    public boolean take(int n) {
        if (!canTake(n)) {
            return false;
        }
        count -= n;
        return true;
    }

    public int getCount() {
        return count;
    }
}

Jar j = new Jar(12);
j.take(12);
j.take(1);
j.take(-3);
System.out.println(j.getCount());

public class Cube {
    private int side;

    public Cube(int side) {
        side = side;
    }

    public int volume() {
        return side * side * side;
    }
}

public class Dial {
    private int reading;

    public Dial(int start) {
        reading = start;
    }

    private void bump() {
        reading++;
    }

    public void use() {
        bump();
    }

    public int getReading() {
        return reading;
    }
}

Meter m = new Dial(5);
Meter n = new Dial(5);
m.use();

I.   m and n each have their own reading
II.  use() may call bump() because both are in the same class
III. code outside Dial may call m.bump()

public class Account {
    private int balance;
    // ...
}

public class Pass {
    // design goes here
}

public class Counter {
    private int count;

    public Counter() {
        count = 0;
    }

    public void add() {
        count++;
    }

    public int getCount() {
        count++;
        return count - 1;
    }
}

public class Item {
    private double price;

    // which header belongs here?
}

public class Cubby {
    private int items;

    public int getItems() {
        return items;
    }
}

// in a different class:
Cubby L = new Cubby();
L.items = 5;
System.out.println(L.getItems());

I.   the hourlyRate instance variable
II.  a roundToCents helper used by two other
     methods inside the class
III. the getPay method the reporting screen calls

public class Account {
    private int limit;

    // which version?
}

public class Jar {
    private int level;

    public Jar() {
        level = 0;
    }

    public void fill(int n) {
        if (level + n <= 15) {
            level += n;
        }
    }

    public int getLevel() {
        return level;
    }
}

Jar j = new Jar();
j.fill(9);
j.fill(6);
j.fill(2);
System.out.println(j.getLevel());

public class Gauge {
    private int level;

    public Gauge(int start) {
        level = clamp(start);
    }

    private int clamp(int n) {
        if (n > 10) {
            return 10;
        }
        if (n < 0) {
            return 0;
        }
        return n;
    }

    public void set(int n) {
        level = clamp(n);
    }

    public int getLevel() {
        return level;
    }
}

Gauge g = new Gauge(25);
g.set(-4);
g.set(10);
System.out.println(g.getLevel());

FRQ Practice

Free-response question 2 is Class Design. You are given a scenario and a table of interactions, and you build the class to match. This one is worth 4 points.

Every header below is written for you, because writing method bodies from nothing is 3.5. What 3.3 asks is the part that is here: put the data out of reach, and make each behavior the only legal way to change it. A copy that can be lent twice, or that a caller can reach into and mark returned, is the failure this lesson exists to prevent.

A school library tracks one physical copy of a book. It is lent and returned, it counts how many times it has been lent, and it accumulates late fees, with a cap so a single disastrous return cannot bankrupt a student.

Scoring: 1 point for attributes that are genuinely out of reach, 1 point for the constructor starting every one of them, 1 point for lend and returnCopy refusing the impossible states rather than trusting the caller, and 1 point for the fee cap and the accessors.

Choose your lane

Summary

A class is four parts with one job. The header names it and is always public in this course. The instance variables hold what each object knows and are private, so the class is the only thing that can change them. The constructor, also always public, gives those variables their starting values. The methods are the interface: public when they are what the class offers, private when they are how it does its work.

Two method shapes carry most of the exam's weight. An accessor reports a value, returns the same type as the field it reports, and changes nothing at all. A mutator changes a value, returns void unless a success flag is asked for, and is where the class's rule is enforced, because it is the only door in.

That combination is encapsulation, and its whole value is that the guarantee becomes real. A class with a private score and a clamping mutator can promise the score is between 0 and 100 and be believed. Make the field public and the promise evaporates, because any caller can write past the check without the class ever finding out.

Frequently asked questions

Related lessons

Unit 3: Class Creation

All 9 lessons in this unit. You are on 3.3.

1. 3.1 Abstraction and Program Design
2. 3.2 Impact of Program Design
3. 3.3 Anatomy of a Class
4. 3.4 Constructors
5. 3.5 Methods: How to Write Them
6. 3.6 Methods: Passing and Returning Object References
7. 3.7 Class Variables and Methods
8. 3.8 Scope and Access
9. 3.9 The this Keyword

Test yourself on this unit

The rest of the course