AP Computer Science A

Primitive Types

Java's primitive data types (int, double, boolean, char), variable declaration and initialization, arithmetic operators including integer division and the modulus operator, operator precedence, and type casting between int and double, including the precision loss that occurs when casting double to int.

Using Objects

Instantiating objects with the 'new' keyword and constructors, calling instance methods and understanding the distinction between void and value-returning methods, object references versus primitive values (and how this affects parameter passing and aliasing), and using built-in classes like String and Math.

Boolean Expressions & if Statements

Relational operators (==, !=, <, >, etc.) and logical operators (&&, ||, !) including short-circuit evaluation, if/else if/else chains and nested conditionals, and De Morgan's laws for simplifying compound boolean expressions — a frequent source of logic-error questions.

Iteration

For loops (initialization, condition, update) versus while loops, and when each is more natural to use, nested loops for processing 2-D structures, and common iteration patterns like accumulator variables, counting matches, and finding min/max values while traversing a collection.

Writing Classes

Defining classes with instance variables, constructors (including overloaded constructors), accessor (getter) and mutator (setter) methods, encapsulation via private instance variables with public methods controlling access, and the 'this' keyword for disambiguating instance variables from parameters.

Arrays

Declaring, initializing, and traversing 1-D arrays with both indexed for-loops and enhanced for-loops, common array algorithms (finding max/min, computing a sum/average, searching for a value, reversing), and the distinction between array length (a field, no parentheses) versus String length() (a method).

ArrayLists

The ArrayList<E> generic class and its key methods (add, remove, get, set, size), traversing an ArrayList with both standard and enhanced for-loops (and the ConcurrentModificationException risk when removing elements during an enhanced for-loop), and converting between arrays and ArrayLists.

2-D Arrays

Declaring and initializing 2-D arrays (arrays of arrays), traversing with nested loops (row-major vs. column-major order), and common 2-D array algorithms like summing rows/columns, finding a value, and processing grid-like data — a frequent, heavily-weighted FRQ topic.

Inheritance

The 'extends' keyword for creating subclasses, method overriding (same signature, different implementation) versus overloading (different signature), the 'super' keyword for calling a superclass's constructor or methods, and polymorphism — how a superclass reference can point to a subclass object and calls the overridden method at runtime.

Recursion

Writing recursive methods with a base case (stopping condition) and a recursive case that moves toward it, tracing recursive calls using a call stack/trace diagram, and classic recursive algorithms including factorial, Fibonacci, and recursive array/2-D array traversal — a topic many students find conceptually difficult and worth extra practice.

Primitive Types

What does this print? int a = 7; int b = 2; double result = a / b; System.out.println(result);

Output: 3.0, not 3.5. a / b is integer division (7/2 = 3, remainder discarded) that happens before the result is ever assigned to a double. The fix is casting an operand first: (double) a / b.

Using Objects

What does this print? String s = "Hello"; String t = new String("Hello"); System.out.println(s == t);

Output: false, even though s.equals(t) would be true. == compares object references (memory addresses), not content — two separately constructed String objects have different references even with identical characters.

Boolean Expressions & if Statements

Simplify using De Morgan's law: !(x > 5 && y < 10).

Equivalent to (x <= 5 || y >= 10) — negating an AND flips it to an OR, and each individual comparison also flips (negating > gives <=, negating < gives >=).

Iteration

Trace this nested loop: for (int i=1; i<=3; i++) { for (int j=1; j<=i; j++) System.out.print("*"); System.out.println(); }

Output is a right triangle: *, then **, then *** on three lines. The outer loop controls the row; the inner loop's upper bound depends on the outer variable — this pattern (an inner bound tied to the outer counter) is a recurring FRQ structure.

Arrays

Find the maximum in int[] arr = {3, 7, 2, 9, 4};

Initialize max = arr[0] (= 3), then loop from index 1, updating max whenever a larger value appears. Final answer: 9. The classic trap is initializing max = 0 instead — that silently fails whenever every array value is negative.

ArrayLists

Why does this throw an exception? Removing elements from an ArrayList inside an enhanced for-loop.

It throws ConcurrentModificationException — modifying a collection's size while an enhanced for-loop iterates over it is never safe. The fix: iterate backwards with an indexed for-loop, or use an Iterator's own remove() method.

2-D Arrays

Sum each row of a 2-D array and store the results in a 1-D array.

Use a nested loop: the outer loop walks rows, the inner loop walks columns accumulating a running sum that resets to 0 at the start of each new row — forgetting that reset (carrying a total across rows) is the single most common bug in this pattern.

Inheritance

What gets called? Animal a = new Dog(); a.makeSound();, where Dog overrides makeSound().

Dog's version runs — polymorphism means the method called depends on the object's actual runtime type (Dog), not the reference's declared type (Animal). This dynamic dispatch is the mechanism behind most FRQ inheritance questions.

Recursion

Trace factorial(4) given factorial(n) { return n <= 1 ? 1 : n * factorial(n-1); }

Calls unwind down to factorial(1) = 1, then multiply back up: 2×1, 3×2, 4×6 = 24. Every recursive method needs a base case that stops the recursion and a recursive case that provably moves toward it — missing either causes infinite recursion and a StackOverflowError.