What you will learn

• Define abstraction, data abstraction, and procedural abstraction, and say what each one hides
• Turn a written specification into a list of attributes and a list of behaviors
• Choose between an instance variable and a class variable using the one design question
• Explain why attributes are private, and what breaks when they are not
• Reject an attribute that should be a computed behavior, and one that belongs to another class
• Predict what a design produces before it is written, including shared-counter and aliasing cases

Why this matters on the exam

Under the 2025 CED, AP CSA is four units, and Unit 3: Class Creation is worth roughly a quarter of the multiple-choice section. Its real weight is larger than that number suggests, because free-response question 2 is Class Design every single year. You are handed a scenario and a table of calls and results, and you write the class from nothing: the header, the private instance variables, the constructor, and the methods.

Lesson 3.1 is where the points on that question are decided. Two of the four rubric points in a typical Class Design question go to the attributes and the constructor, and the single most common way to lose them is a design error rather than a syntax error: an attribute declared per object when the specification describes one shared value, a value stored that should have been computed, or a public field where the specification implies the class protects its own data. None of those produce a compiler message. They produce working code that is wrong, which is exactly what this lesson trains you to catch.

On the multiple-choice side, 3.1 shows up as design-judgment questions: which class design is best, which of I, II and III are appropriate instance variables, and what a program prints when a static counter is involved. Those questions are answerable in fifteen seconds if you have the one design question memorized, and are near-coin-flips if you do not.

The problem this solves

A campus wants an app for its scooter fleet. Somebody has to decide, before any code exists, what a scooter is to the program. Its color and its serial number plate do not matter. Its battery level, whether it is currently rented, and the fleet's running count of scooters do. That decision, made on paper in about five minutes, is the difference between a class you can finish and one you rewrite twice. FRQ 2 on the exam hands you a scenario and a table of interactions and asks you to make exactly that decision, then implement it.

Design first: turn a real thing into a class

Abstraction is reducing complexity by focusing on the main idea and hiding the details that do not matter for the question at hand. Designing a class is abstraction in two directions at once: you decide what an object knows and what an object does, and you throw away everything else.

The habit that pays off on FRQ 2 is simple. Read the specification, underline the nouns, underline the verbs. The nouns become attributes (the data). The verbs become behaviors (the methods). Do that on paper before you type a single line.

Nouns become attributes, verbs become behaviors

// Spec: a scooter has a battery level and
// can be rented, parked, and ridden.

public class Scooter {
    // attributes: what it KNOWS
    private int battery;
    private boolean rented;

    // behaviors: what it DOES
    public void rent() { ... }
    public void park() { ... }
    public void ride(int minutes) { ... }
}

One per object, or one for the whole class?

An attribute is declared in the class, outside every method and constructor. There are two kinds, and choosing the wrong one is the single most common design mistake in this unit.

public class Ticket {
    // class variable: ONE copy, shared
    private static int issued = 0;

    // instance variable: one PER object
    private int number;

    public Ticket() {
        issued++;
        number = issued;
    }
}

Ask one question: does every object need its own value? Each ticket needs its own number, so that is an instance variable. The running count of how many tickets exist belongs to the whole class, so that is a class variable.

Procedural abstraction: name it, decompose it, generalize it

A procedural abstraction gives a process a name so it can be used knowing only what it does, not how. Three moves follow from it.

• Name it. isAvailable() says what it means; battery >= 20 && !rented makes the reader re-derive it every time.
• Decompose it. Break a large behavior into smaller methods, each doing one job. Method decomposition is what turns a 40-line method into four readable ones.
• Generalize it with a parameter. Three near-identical methods almost always want to be one method with a parameter.

// duplicated: three near-copies
public int priceWithTax5() { ... }
public int priceWithTax7() { ... }
public int priceWithTax9() { ... }

// generalized: one method, any rate
public int priceWithTax(int percent) {
    return subtotal + subtotal * percent / 100;
}

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 design in memory

Two Scooter objects and one shared class variable. Watch each object get its own copy of the instance variables while the class variable count is shared, then watch a second name point at an existing object.

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.

Design Decisions Arcade

Six quick rounds. Read the class and the client code, then type the final value. These are the six design traps that show up again and again on FRQ 2: per-object versus shared, integer division, reference copying, and parameter copying.

public class S {
    private int b;
    public S(int start) { b = start; }
    public void ride(int m) { b -= m / 3; }
    public int get() { return b; }
}
S s = new S(60);
s.ride(11);
s.ride(7);
int x = s.get();

public class T {
    private static int n = 0;
    public T() { n++; }
    public static int get() { return n; }
}
T a = new T();
T b = new T();
T c = new T();
T d = new T();
int x = T.get();

public class T {
    private int n = 0;
    public T() { n++; }
    public int get() { return n; }
}
T a = new T();
T b = new T();
int x = b.get();

public class Box {
    private int v;
    public Box(int start) { v = start; }
    public void set(int n) { v = n; }
    public int get() { return v; }
}
Box p = new Box(4);
Box q = p;
q.set(12);
int x = p.get();

public class M {
    public static void bump(int n) { n += 100; }
}
int x = 5;
M.bump(x);

public class Meter {
    private int min;
    private int rate;
    public Meter(int r) { rate = r; min = 0; }
    public void insert(int c) { min += c / rate; }
    public int get() { return min; }
}
Meter m = new Meter(20);
m.insert(95);
m.insert(50);
int x = m.get();

Multiple choice

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

public class Tank {
    private int gas;

    public Tank(int start) {
        gas = start;
    }

    public void drive(int miles) {
        gas -= miles / 4;
    }

    public int getGas() {
        return gas;
    }
}

Tank t = new Tank(30);
t.drive(9);
t.drive(7);
System.out.println(t.getGas());

public class Ticket {
    private int issued = 0;
    private int number;

    public Ticket() {
        issued++;
        number = issued;
    }

    public int getNumber() {
        return number;
    }
}

public class Locker {
    private static int built = 0;
    private int capacity;
    private int count;

    public Locker(int cap) {
        built++;
        capacity = cap;
        count = 0;
    }

    public static int getBuilt() { return built; }
    public int getCount() { return count; }
}

Locker a = new Locker(3);
Locker b = new Locker(5);

I.   a and b hold different values for capacity
II.  Locker.getBuilt() returns 2
III. a and b share one single count variable

public class Playlist {
    // attributes go here
    // behaviors go below
}

public class Cart {
    private int subtotal;

    public int priceWithTax5() { ... }
    public int priceWithTax7() { ... }
    public int priceWithTax9() { ... }
}

public class Inventory {
    public int count;

    public Inventory(int start) {
        if (start < 0) {
            start = 0;
        }
        count = start;
    }

    public void remove(int n) {
        if (n <= count) {
            count -= n;
        }
    }
}

public class LoanCopy {
    // one of these four is declared at the wrong level
}

public class Kiln {
    // attributes?

    // behaviors?
}

I.   servings, the number of portions this recipe makes
II.  totalCalories, found by adding up every ingredient
III. printedCopies, how many times any recipe in the
     app has ever been printed

public class Wristband {
    private static int made = 0;
    private int id;

    public Wristband() {
        id = made;
        made++;
    }

    public int getId() {
        return id;
    }
}

Wristband a = new Wristband();
Wristband b = new Wristband();
Wristband c = a;
Wristband d = new Wristband();
System.out.println(d.getId());

public class Meter {
    private int minutes;
    private int rate;

    public Meter(int centsPerMinute) {
        rate = centsPerMinute;
        minutes = 0;
    }

    public void insert(int cents) {
        minutes += cents / rate;
    }

    public void tick(int n) {
        minutes -= n;
        if (minutes < 0) {
            minutes = 0;
        }
    }

    public int getMinutes() {
        return minutes;
    }
}

Meter m = new Meter(25);
Meter same = m;
m.insert(70);
same.insert(60);
same.tick(4);
System.out.println(m.getMinutes());

FRQ Practice

Free-response question 2 on the AP Exam is Class Design, and it is the one question that is Unit 3 from top to bottom. It hands you a scenario and a table showing how the class is used and what each call produces, and you build the class to match.

That question has two halves. The first is the design: which attributes exist, which level each one belongs at, and which values are computed rather than stored. The second is the syntax that expresses it, which arrives across 3.3 to 3.7. This is the design half, worth 4 points. Every header below is written for you; the decisions are not.

A gym issues a membership card to each member. A card counts that member's check-ins and knows the monthly fee that member pays. The gym also wants to know how many cards it has issued in total.

Scoring: 1 point for placing the three attributes at the right level, 1 point for the constructor doing all three of its jobs, 1 point for isFrequent landing exactly on the boundary, and 1 point for costPerVisit using integer division and guarding the no-visits case.

Choose your lane

Summary

Designing a class is abstraction applied twice. You decide what an object knows, which becomes its attributes, and what an object does, which becomes its behaviors, and you discard everything the program has no use for. The mechanical version of that is to read the specification, underline the nouns and the verbs, and let the two lists become the two halves of the class.

Every attribute then faces one question: does every object need its own value? A per-object answer means an instance variable, one copy for every object. A shared answer means a class variable, declared static, with exactly one copy no matter how many objects exist. Getting this backwards is the defining error of the unit, and it never announces itself: a per-object counter compiles cleanly and reports 1 forever.

Two more rules finish the design. Store only what is independent, and compute anything that can be derived, so the object cannot hold two facts that disagree. And keep attributes private, because a class can only guarantee a rule when all access to its data runs through its own methods. Procedural abstraction is the same instinct applied to code: name a process, decompose a long behavior into small ones, and replace near-identical methods with one method that takes a parameter.

Frequently asked questions

Related lessons

Unit 3: Class Creation

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

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