Review AP CSA Unit 1 to build your foundation in Java: variables, data types, arithmetic expressions, object creation, and calling methods from built-in classes like Math and String. This unit carries 15-25% of the exam weight and appears in nearly every multiple-choice question that asks you to trace code.
Fiveable's AP Computer Science A Unit 1 review covers 15 topics, with guided practice questions for the unit.
Use the topic guides, key terms, and practice questions available for this unit to work through every concept before exam day.
Unit 1 covers the core mechanics of Java that every other unit builds on. You start with how algorithms work and how Java turns source code into a running program, then move through variables, expressions, assignment, and casting. The second half of the unit shifts to object-oriented thinking: what a class is, how to create objects with constructors, and how to call instance and class methods. The Math and String classes give you concrete practice with all of these ideas.
Unit 1 teaches you to write and trace basic Java programs using variables, arithmetic expressions, object creation, and method calls. The key skill is predicting exactly what value a variable holds or what output a program produces after each statement executes.
Java has three primitive types you need for this course: int, double, and boolean. Arithmetic follows operator precedence (*, /, % before +/-), and dividing two ints drops the decimal. Casting with (int) or (double) lets you convert between types, but casting a double to an int truncates, it does not round.
A class is a blueprint; an object is a specific instance created from that blueprint. You create objects with the new keyword and a constructor call, like new String("hello"). A reference variable stores the memory address of the object, not the object itself. Calling a method on a null reference causes a NullPointerException.
Math class methods (Math.abs, Math.pow, Math.sqrt, Math.random) are static, so you call them on the class name. String methods (length, substring, indexOf, equals, compareTo) are instance methods called on a String object. Strings are immutable: methods return new String objects and never change the original.
The single most important distinction in Unit 1 is the difference between primitive types (int, double, boolean) and reference types (String, Math, any class). Primitives store their value directly in the variable. Reference variables store a pointer to an object in memory. This distinction explains casting behavior, NullPointerException, String immutability, and how arguments are passed to methods using call by value. Keep this mental model active as you trace every code segment in the unit.
Algorithms are step-by-step processes where sequencing matters. Java code is compiled before it runs, and the compiler catches syntax errors. Logic errors and run-time errors require testing or execution to detect.
Java variables have a declared type: int, double, or boolean for primitives, or a class name for reference types. A variable must be initialized before use. Reference variables hold a memory address, not the object itself.
System.out.print and System.out.println display output. Arithmetic follows operator precedence, and integer division truncates. The + operator concatenates strings when at least one operand is a String.
The = operator evaluates the right-hand expression and stores the result in the left-hand variable. Types must be compatible. The Scanner class reads text input, but specific input code is not tested on the AP exam.
Use (int) to truncate a double to an int, or (double) to widen an int. Integer overflow occurs when an int result exceeds Integer.MAX_VALUE. Round-off error occurs when a double cannot be stored exactly.
Operators +=, -=, *=, /=, and %= combine arithmetic with assignment. x++ and x-- add or subtract 1 from a variable. Trace the variable value after each compound assignment statement.
Libraries are collections of classes. An API specification documents a class's attributes (data in variables) and behaviors (methods). You use a class by reading its API, not its source code.
Java supports single-line (//), block (/* /), and Javadoc (/* */) comments. Comments are ignored by the compiler. Preconditions and postconditions document what a method requires and guarantees.
A method signature is the method name plus its ordered parameter types. Arguments must match in number, order, and compatible type. Void methods return nothing; non-void methods return a value that must be stored or used.
Static methods belong to the class, not an object. Call them with ClassName.methodName(args). The keyword static appears in the method header. Inside the defining class, the class name is optional.
Math is in java.lang and needs no import. Its methods are all static: Math.abs, Math.pow, Math.sqrt, and Math.random. Use the scale-and-shift formula with Math.random() to generate random integers in a range.
A class is a blueprint; an object is a specific instance. A reference variable holds the memory address of an object. The current AP CSA course focuses on creating and using objects, not designing inheritance hierarchies.
Create objects with new ClassName(args). The constructor name matches the class name and can be overloaded. Arguments are passed by value. A reference variable holds the object's address or null.
Call instance methods with objectReference.methodName(args). Each object uses its own data. Calling a method on a null reference throws NullPointerException at runtime.
String is an immutable reference type. Use length(), substring(), indexOf(), equals(), and compareTo() from the Java Quick Reference. Indices run from 0 to length()-1. Use equals(), not ==, to compare String content.
This snapshot uses Fiveable practice activity to show where students tend to miss questions and which review moves are worth prioritizing first.
Across 8.5k multiple-choice practice attempts for this unit.
Practice activity included in this snapshot.
An algorithm is a step-by-step process where sequencing matters: each step runs one at a time in order. Java source code is written in a text editor or IDE, then a compiler translates it into a form the computer can run. The compiler catches some errors before the program runs, but not all of them.
Given a short Java program with a missing semicolon, an incorrect formula, and a divide-by-zero, can you identify which error is a syntax error, which is a logic error, and which is a run-time error?
| Error type | When detected | Example |
|---|---|---|
| Syntax error | Compile time | Missing semicolon, unclosed brace |
| Logic error | Testing (not compiler) | Wrong formula produces bad output |
| Run-time error | During execution | Integer divide by zero |
| Exception | During execution | NullPointerException, ArithmeticException |
A variable is a named storage location whose value can change while the program runs. Every variable has a declared type. The three primitive types in AP CSA are int (whole numbers), double (real numbers), and boolean (true or false). Reference types, like String, store a pointer to an object rather than the value itself. You must initialize a variable before using it in an expression.
Write a declaration for each of the three primitive types and one reference type. Then identify which type you would use to store a student's GPA, a count of items, and a flag for whether a user is logged in.
| Type | Category | Example values |
|---|---|---|
| int | Primitive | 0, -5, 1000 |
| double | Primitive | 3.14, -0.5, 2.0 |
| boolean | Primitive | true, false |
| String | Reference | "hello", "AP CSA" |
System.out.print displays output and keeps the cursor on the same line; System.out.println moves to a new line after printing. Arithmetic expressions follow precedence rules: *, /, and % evaluate before + and -. When both operands are int, division truncates the decimal. Mixing an int and a double promotes the result to double. The + operator concatenates strings when at least one operand is a String.
Predict the output of: System.out.println(7 / 2 + " " + 7 % 2 + " " + 7.0 / 2);
The assignment operator = evaluates the right-hand expression first, then stores the result in the left-hand variable. The value must be a compatible type. Casting with (int) or (double) converts between primitive types explicitly. Casting a double to an int truncates toward zero. Widening from int to double happens automatically. Integer overflow occurs when an int expression exceeds Integer.MAX_VALUE or goes below Integer.MIN_VALUE, producing an unexpected in-range result. Round-off error occurs when a double value cannot be represented exactly in memory.
What does (int)(7.9) evaluate to? What happens if you add 1 to Integer.MAX_VALUE? Explain both results.
Compound assignment operators combine an arithmetic operation with assignment in one step. x += 5 is equivalent to x = x + 5. The post-increment operator x++ adds 1 to x and stores the result back in x. These operators appear frequently in loop counters and running totals, so tracing the exact value of a variable after each statement is the key skill.
If x = 10, what is x after x *= 3; then x %= 7;? Trace each step.
A library is a collection of classes grouped into packages. An API specification tells you how to use those classes without needing to read their source code. Attributes are the data a class stores in variables; behaviors are what the class can do, defined by methods. Comments document code for human readers but are ignored by the compiler. Preconditions state what must be true before a method runs; postconditions state what is guaranteed to be true after it runs.
A method has the precondition that its int parameter must be positive. Who is responsible for ensuring this condition is met before the method is called?
A method signature consists of the method name and its ordered list of parameter types. Arguments passed in a method call must match the parameter list in number, order, and compatible type. Void methods do not return a value and cannot be used in an expression. Non-void methods return a value that must be stored or used. Static (class) methods belong to the class, not to any object, and are called using the class name and dot operator, like Math.sqrt(16).
Math.abs is overloaded with versions for int and double. If you call Math.abs(-3), which version runs and what does it return?
| Method type | Called on | Syntax example | Returns value? |
|---|---|---|---|
| Static (class) method | Class name | Math.sqrt(9.0) | Yes (double) |
| Instance method | Object reference | str.length() | Yes (int) |
| Void method | Class or object | System.out.println(x) | No |
The Math class is in java.lang, so no import is needed. All Math methods are static. The four methods on the Java Quick Reference are Math.abs (int and double versions), Math.pow(base, exponent), Math.sqrt(x), and Math.random(). Math.random() returns a double in [0.0, 1.0). To generate a random int in a range, use the scale-and-shift pattern: (int)(Math.random() * (max - min + 1)) + min for an inclusive range.
Write an expression that generates a random integer from 1 to 6 inclusive, simulating a die roll.
A class is the blueprint that defines attributes (instance variables) and behaviors (methods). An object is a specific instance of a class created at runtime. You create an object with the new keyword followed by a constructor call. The constructor's name matches the class name, and constructors can be overloaded. A reference variable stores the memory address of the object. If a reference variable holds null, calling any method on it causes a NullPointerException.
A class Student has two constructors: Student(String name) and Student(String name, int grade). Which constructor runs for new Student("Alex")? What does the reference variable store after this call?
Instance methods are called on a specific object using the dot operator: objectReference.methodName(arguments). Each object runs the method using its own instance variables, so two objects of the same class can return different results from the same method call. A void instance method is called as a standalone statement. A non-void instance method returns a value that must be stored or used. Always verify the reference is not null before calling a method on it.
If String s = null; what happens when you call s.length()? Name the error and explain why it occurs.
A String is an immutable reference type in java.lang. You can create one with a string literal or with new String(). Because Strings are immutable, methods like substring and toUpperCase return new String objects; they do not modify the original. String indices run from 0 to length() - 1. The five String methods on the Java Quick Reference are length(), substring(from, to), substring(from), indexOf(str), equals(other), and compareTo(other).
For String s = "computer"; what does s.substring(0, 4) return? What does s.indexOf("put") return? What does s.length() return?
Try AP-style multiple-choice questions and written prompts after you review the notes.
A timed, AP-style test built only from unit 1 questions — multiple choice plus free response, scored with AI feedback. Use the standard format or build your own.
| Term | Definition |
|---|---|
| compiler | A program that translates Java source code into a runnable form and detects syntax errors before the program executes. |
| logic error | A mistake in the algorithm that causes incorrect output; the program compiles and runs but produces an unexpected result, detected only through testing. |
| arithmetic expression | A combination of numeric values, variables, and operators (+, -, *, /, %) that evaluates to a single int or double result following operator precedence rules. |
| integer division | Division of two int values that discards the fractional part: 7 / 2 evaluates to 3, not 3.5. |
| remainder operator | The % operator returns the remainder after division: 7 % 3 evaluates to 1. Useful for divisibility checks and cycling through ranges. |
| cast operator | Syntax of the form (int) or (double) that explicitly converts a value to the specified primitive type. Casting a double to int truncates toward zero. |
| round-off error | A loss of precision when a double value cannot be stored exactly in memory, causing the result to be rounded to the nearest representable value. |
| object instantiation | Creating a new object from a class using the new keyword and a constructor call, for example new String("hello") or new Scanner(System.in). |
| object reference | The value stored in a reference-type variable: a memory address pointing to an object on the heap, not the object's data directly. |
| null reference | A reference variable that does not point to any object. Calling a method on a null reference causes a NullPointerException at runtime. |
| call by value | The argument-passing mechanism in Java: a copy of the argument's value is passed to the parameter. Changes to the parameter inside the method do not affect the original variable. |
| instance method | A method that belongs to an object and is called using the dot operator on an object reference: objectRef.methodName(args). |
| Math.random() | A static Math class method that returns a random double d where 0.0 <= d < 1.0. Scale and cast to produce random integers in a specific range. |
| string literal | A sequence of characters enclosed in double quotes, such as "hello", used to create a String object directly in code. |
| operator precedence | The rules that determine evaluation order in a compound expression: *, /, and % are evaluated before + and -. Parentheses override the default order. |
When both operands are int, Java discards the decimal: 5 / 2 is 2, not 2.5. To get 2.5, at least one operand must be a double: 5.0 / 2 or (double) 5 / 2. This mistake causes silent wrong answers in arithmetic traces.
The == operator checks whether two reference variables point to the same object in memory, not whether they contain the same characters. Always use .equals() to compare String values: str1.equals(str2).
(int) 3.9 produces 3, not 4. Casting toward zero always drops the decimal. To round to the nearest integer, use (int)(x + 0.5) for nonnegative values.
If a reference variable has not been assigned an object (or was assigned null), calling any method on it throws NullPointerException at runtime. Always confirm an object was created with new before calling its methods.
String indices start at 0, not 1. The last valid index is length() - 1. In substring(from, to), the character at index to is not included. Accessing an out-of-range index throws StringIndexOutOfBoundsException.
A large portion of AP CSA multiple-choice questions ask you to trace a short code segment and identify the exact output or the value stored in a variable. Unit 1 skills, including integer division, casting, compound assignment, and String method calls, appear directly in these traces. Practice evaluating expressions step by step without a compiler.
The AP CSA exam frequently presents a class or method you have not seen before and asks you to call it correctly or predict its return value. Unit 1 teaches you to read a method signature, match arguments to parameters by type and order, and determine whether the return value must be stored. This skill applies to every class you encounter on the exam.
Free-response questions often require you to write code that instantiates objects, calls instance methods, and uses return values in expressions. Unit 1 establishes the syntax for new, the dot operator, and method calls. Errors like calling a method on null or using == instead of equals on Strings are common points of deduction on written-response tasks.
Given a Java program, distinguish syntax errors (caught by compiler), logic errors (wrong output), and run-time errors or exceptions (crash during execution). Know an example of each.
Write correct declarations for int, double, boolean, and String. Explain why you would choose double over int for a GPA and int over double to avoid rounding errors in a counter.
Evaluate expressions like (int)(7.9), 7 / 2, 7 % 3, and 7.0 / 2 without a compiler. Apply operator precedence and identify when a result is int versus double.
Given a sequence of statements using +=, *=, %=, x++, and x--, determine the exact value stored in each variable after every statement.
Given a method header like static double pow(double base, double exponent), write a valid call, identify the return type, and explain what happens to the return value if it is not stored.
Write code to instantiate an object using new, call an instance method with the dot operator, and explain what NullPointerException is and when it occurs.
Write expressions using Math.abs, Math.pow, Math.sqrt, and Math.random. Trace String method calls for length(), substring(from, to), indexOf(), equals(), and compareTo() on a given String.
Read the Topic 1.1 guide on algorithms, sequencing, and the compile-run cycle. Write one example of each error type (syntax, logic, run-time) in your own words. Use the key terms list to check your definitions of compiler, logic error, and exception.
Work through the topic guides for 1.2 through 1.5 in order. For each guide, write three practice expressions and trace their values by hand before checking. Focus on integer division, the (int) cast, widening conversion, and what happens at Integer.MAX_VALUE.
Read the Topic 1.6 guide and trace at least five sequences of compound assignment statements. Write out the variable value after every single statement. Practice with +=, *=, %=, x++, and x-- in combination.
Read the guides for 1.7 through 1.10. Practice reading a method signature and writing a correct call. Distinguish void from non-void methods and instance methods from static methods. Use the Math class as your main example for static method calls.
Read the guides for 1.11 through 1.15. Write code that creates a String object, calls each of the five Quick Reference String methods, and traces the output. Practice the Math.random() scale-and-shift formula. Then use available practice questions to test your ability to trace object creation and method calls under exam conditions.
Unit 1 printables
Print the unit cheatsheets ($3) or full-length exam ($12) for Unit 1. Yours to keep, no subscription needed.
get printablesAP CSA Unit 1 covers 15 topics that build the foundation of Java programming: algorithms and compilers, variables and data types, expressions and output, assignment statements and input, casting, compound assignment operators, APIs and libraries, documentation with comments, method signatures, calling class methods, the Math class, objects and instantiation, calling instance methods, and String manipulation. See the full topic list at AP CSA Unit 1.
Unit 1 makes up 15-25% of the AP CSA exam, making it one of the most heavily weighted units. It covers core Java concepts like variables, data types, expressions, object creation, and String and Math class methods. A strong grasp of this unit directly supports your performance across the rest of the exam.
The AP CSA Unit 1 progress check in AP Classroom has three parts. Parts 1 and 2 (topics 1.1-1.9) are multiple choice on variables, data types, expressions, input, casting, compound assignment operators, APIs, comments, and method signatures. Part 3 (topics 1.10-1.15) adds multiple choice on class methods, the Math class, objects, instance methods, and String manipulation, plus one free-response question: a partial version of FRQ 1, Methods and Control Structures. Practice with aligned questions at AP CSA Unit 1.
Unit 1 skills feed FRQ 1, Methods and Control Structures. On the AP exam, Part A of FRQ 1 (4 points) asks you to write a method or constructor that calls methods of the given class, and Part B (3 points) asks you to write a method that calls `String` methods. The Unit 1 progress check includes a partial version of this question. To practice, write short methods by hand that create objects, call instance and `Math` methods, and build or slice strings with `substring`, `indexOf`, and `length`, then trace them to check the result. Full FRQ 1 prompts also use loops and `if` statements from Unit 2; find them in AP CSA FRQ practice.
Start with variables and data types, since every other topic in Unit 1 builds on them. Then work through expressions, assignment statements, and casting before moving to method signatures and APIs. Once those feel solid, practice calling Math and String class methods, then move to object creation and calling instance methods. Write small Java programs for each topic rather than just reading. Use the progress check MCQ to spot gaps, and revisit any topic where casting or method calls trip you up. Full topic guides are at AP CSA Unit 1.
public int sumPositive(Scanner in) {
int sum = 0;
int num = in.nextInt();
while (num > 0) {
/* missing code */
}
return sum;
}