AP^® Computer Science A

THE BIG PICTURE. Unit 1 (15–25%) is the foundation of the AP Computer Science A course: primitive data types, variables, expressions, arithmetic, casting, the String class, output, and how to USE classes and methods that someone else has written. You learn Java's vocabulary and grammar; later units add control flow (Unit 2), class design (Unit 3), and collections (Unit 4).

The three primitive types tested on the exam:

• int: 32-bit signed integer. Range $-2^{31}$ to $2^{31}-1$ (about $\pm 2.1 \times 10^9$).
• double: 64-bit floating-point number (decimals). Default for decimal literals like 3.14.
• boolean: true or false. No numeric conversion in Java.
• Java also has char, long, short, byte, and float, but the College Board places these outside the scope of the AP course and exam.

Declaration and initialization:

int count = 0;
double pi = 3.14159;
boolean isReady = true;

A variable must be declared with a type before use; once declared, the type cannot change.

Operators: +, -, *, /, % (modulus, remainder).

Critical rule: integer division. When BOTH operands are int, / discards the fractional part

int x = 7 / 2;   // x is 3, not 3.5
double y = 7.0 / 2;  // y is 3.5 (double promotion)

Modulus (%): returns the remainder after division.

• 17 % 5 = 2 (because 17 = 3 × 5 + 2).
• 12 % 4 = 0 (12 is evenly divisible by 4).
• Useful for: testing divisibility (n % 2 == 0 checks if even); extracting digits (n % 10 gives the ones digit).

Order of precedence (high to low)

1. Parentheses. 2. *, /, % (left-to-right). 3. +, - (left-to-right). 4. Assignment (=) happens last: the whole right side is evaluated, then stored in the variable on the left.

Compound assignment: x += 5 is shorthand for x = x + 5. Similarly -=, *=, /=, %=.

Increment/decrement: x++ and x-- (post-increment/decrement); ++x and --x (pre). For AP, only the statement-level postfix form (x++;) is tested; the prefix form and use inside larger expressions are outside the scope of the exam.

When operands of different types are mixed, Java AUTOMATICALLY promotes:

• int + double → double (the int is promoted to double).
• Result type matches the "wider" operand.

Explicit casting with (type) overrides

double d = 7.8;
int i = (int) d;   // i is 7 (truncates toward zero, does NOT round)

(int) 7.8 gives 7. (int) -7.8 gives -7. Casting truncates, does not round. To round to the nearest integer, the AP idiom is (int) (x + 0.5) for non-negative x (or (int) (x - 0.5) for negative x). Real Java also has Math.round(), but it is not on the AP Java Quick Reference.

Casting double to int loses precision. Casting int to double is safe (no information loss).

Common bug: integer division before assigning to double

double avg = sum / count;   // if sum and count are int, integer division happens BEFORE the assignment
double avg = (double) sum / count;   // forces double division

A String is a sequence of characters (an OBJECT, not a primitive). Created with double quotes:

String name = "Alice";

String concatenation with +

String greeting = "Hello, " + name + "!";   // "Hello, Alice!"
int age = 17;
String s = "Age: " + age;   // "Age: 17" (int auto-converted to String)

Mixed expressions: if either operand is a String, + concatenates. Otherwise, arithmetic

"sum: " + 3 + 4    // "sum: 34" (left-to-right: concat first)
"sum: " + (3 + 4)  // "sum: 7"  (parens force arithmetic)
1 + 2 + "result"   // "3result" (numbers added, then concat)

String methods (memorize the AP-tested ones):

• length(): number of characters. "hello".length() is 5.
• substring(start): from index start to end. "hello".substring(2) is "llo".
• substring(start, end): from start INCLUSIVE to end EXCLUSIVE. "hello".substring(1, 4) is "ell".
• indexOf(str): returns first index of str, or -1 if not found.
• equals(other): true if equal. ALWAYS use .equals(), NEVER == for Strings.
• compareTo(other): returns negative if this < other, 0 if equal, positive if this > other (lexicographic).

Indexing: strings are 0-indexed. To get the single character at index i as a String, use substring(i, i + 1): "hello".substring(0, 1) is "h"; "hello".substring(4, 5) is "o". "hello".substring(5, 6) throws StringIndexOutOfBoundsException. (Real Java also has charAt(i), which returns a char, but it is not on the AP Java subset.)

Strings are IMMUTABLE. s.substring(0, 3) returns a NEW String; it does not modify s. You must reassign: s = s.substring(0, 3);.

A class is a blueprint; an object is an instance. Math is a class; Math.sqrt(16) calls the static sqrt method.

Static methods are called on the CLASS (Math.sqrt(16)). Instance methods are called on an OBJECT (name.length()).

Creating objects with new:

String s = new String("hello");  // explicit creation (rarely needed for String)

The Math class (memorize for AP):

• Math.abs(x): absolute value.
• Math.pow(base, exp): base^exp (returns double).
• Math.sqrt(x): square root.
• Math.random(): random double in [0.0, 1.0).
• Math.PI and Math.E exist in real Java but are not on the Quick Reference; exam code that needs pi defines its own constant.

Random numbers (typical pattern): to generate a random int in [a, b] inclusive

int n = (int) (Math.random() * (b - a + 1)) + a;

For a=1, b=6 (dice): (int) (Math.random() * 6) + 1 gives 1-6.

Methods may have parameters (input) and return values (output).

int x = Math.abs(-10);    // x is 10
double d = Math.sqrt(25);  // d is 5.0
String first = name.substring(0, 1);   // returns "A" (name unchanged)

Method signature: name + parameter types. Math.abs(int) and Math.abs(double) are different overloads (both are on the Java Quick Reference).

Return value vs side effect: most AP methods return values. Some, like System.out.println(x), have a side effect (printing) and a void return type.

void methods return no value

System.out.println("Hello");   // prints, returns nothing

System.out.println(x): prints x then a newline. System.out.print(x): prints x without newline.

Common gotchas:

• Strings inside print need to be concatenated: System.out.println("count: " + count);
• Inserting a newline mid-string: "\n" or use multiple println calls.

EXAM CONNECTIONS. Unit 1 generates many MC items testing: integer division gotchas, type casting, String method usage, arithmetic operator precedence. FRQ Q1 (Methods and Control Structures) requires calling String methods. Memorize: integer division behavior; % for divisibility/digits; String's length, substring, indexOf, equals; Math methods. ALWAYS use .equals() for String comparison, never ==.