AP Computer Science A: What Actually Matters

The AP Computer Science A exam rewards students who know Java's quirks cold, not just students who understand programming in the abstract. Two sections, 90 minutes each: 40 multiple choice questions worth 50% of your score, and 4 free-response questions worth the other 50%. Most students lose points on the free-response section not because they don't understand the concept, but because they mishandle Java syntax under time pressure.

The four free-response questions aren't random

College Board has kept the FRQ structure consistent for years. Question 1 is almost always methods and control structures on a single class. Question 2 involves a class that implements an interface or extends another class. Question 3 is 2D array manipulation. Question 4 covers ArrayList or other collection classes. Knowing this in advance means you can practice each question type specifically instead of doing generic "AP CS practice problems."

For Question 3 especially, memorize the nested-loop pattern for traversing a 2D array both row-major and column-major:

for (int row = 0; row < arr.length; row++) {
    for (int col = 0; col < arr[row].length; col++) {
        // process arr[row][col]
    }
}

The graders (called "Readers") use a rubric that awards partial credit for specific lines of correct logic, even if your final answer is wrong. Writing return null; as a placeholder when you're stuck on a method that returns an object is worth more than leaving it blank.

Multiple choice traps that show up every year

Questions about == versus .equals() for String comparison appear almost every administration. == compares references for objects; .equals() compares content. This trips up students because Java's string literal pool sometimes makes == return true for strings that shouldn't logically be equal by reference, which is exactly the kind of gotcha the exam likes to test.

Operator precedence and integer division are the other recurring traps. 7 / 2 evaluates to 3, not 3.5, because both operands are ints. Cast one operand to double, like (double) 7 / 2, to get the decimal result. Questions also test what happens when you mix int and double in expressions without an explicit cast — know that Java promotes automatically in mixed arithmetic but truncates when assigning a double result back to an int variable.

Inheritance and polymorphism carry more weight than they seem to

Big Idea 4 (Class and Object Oriented Programming) shows up across both sections, not just in dedicated inheritance questions. Understand the difference between overriding and overloading, and know that Java resolves overridden methods at runtime based on the actual object type, not the declared reference type:

Animal a = new Dog();
a.makeSound(); // calls Dog's version, not Animal's

This is runtime polymorphism, and the exam tests it by giving you a reference of one type pointing to an object of a subclass, then asking which method actually executes. Static methods and instance variables don't follow this rule — they resolve based on the declared type, and that distinction is a favorite exam trap.

Array and ArrayList mechanics you need automatic, not looked-up

You won't have access to Java documentation during the exam. Memorize these without hesitation:

• array.length (no parentheses, it's a field)
• list.size() (parentheses, it's a method)
• list.add(index, element) shifts everything right
• list.remove(index) shifts everything left and returns the removed element
• Removing elements from an ArrayList while iterating forward with a for-each loop throws ConcurrentModificationException; iterate backward with an indexed loop instead when removing

That last point is genuinely one of the most common logic bugs in FRQ responses, and Readers see it constantly.

How to spend your last two weeks

Do full past FRQs under actual timed conditions — College Board publishes real past exams with scoring guidelines showing exactly how points were awarded. Read the scoring guidelines closely; they reveal how granular the partial credit really is, sometimes down to a single correctly declared variable. For multiple choice, focus review time on recursion tracing and 2D array indexing, since those are where careless errors cost the most points relative to how simple the underlying concept actually is.

If you want to build the Java fundamentals underneath all of this more solidly, or see worked examples of classes, inheritance, and array manipulation broken down step by step, check out the Python and Computer Science segments in Korra Studio's library for more structured practice.