AP-CSA
Coming Soon
Expected availability: Summer 2026
This course is in active development. Preview the scope below and create a free account to be notified the moment it goes live.
AP® Computer Science A
AP Computer Science A teaches Java fundamentals, covering primitive types, objects, boolean logic, control flow, iteration, and class design, preparing students for college-level programming and the AP exam.
180
Minutes
44
Questions
3/5
Passing Score
$98
Exam Cost
Who Should Take This
High school juniors and seniors who aim to earn college credit or strengthen their problem‑solving skills should enroll. The course suits learners with basic algebra knowledge but little to no programming experience, and it targets those seeking to master Java syntax, object‑oriented concepts, and algorithmic reasoning for the AP Computer Science A exam.
What's Covered
1
Unit 1: Primitive Types
2
Unit 2: Using Objects
3
Unit 3: Boolean Expressions and if Statements
4
Unit 4: Iteration
5
Unit 5: Writing Classes
6
Unit 6: Array
7
Unit 7: ArrayList
8
Unit 8: 2D Array
9
Unit 9: Inheritance
10
Unit 10: Recursion
What's Included in AccelaStudy® AI
Adaptive Knowledge Graph
Practice Questions
Lesson Modules
Console Simulator Labs
Exam Tips & Strategy
20 Activity Formats
Course Outline
60 learning goals
1
Unit 1: Primitive Types
1 topic
Variables and Data Types
- Identify the three primitive data types used in AP CSA (int, double, boolean) and declare and initialize variables of each type using appropriate literal values.
- Explain the difference between integer division and floating-point division in Java and predict the result of arithmetic expressions involving mixed types and type casting.
- Apply arithmetic operators (+, -, *, /, %), compound assignment operators (+=, -=, *=, /=, %=), and increment/decrement operators (++, --) to evaluate expressions and trace variable values through a sequence of statements.
- Identify and correct common errors in arithmetic expressions including integer overflow, loss of precision in casting, and unintended integer division when computing ratios.
2
Unit 2: Using Objects
1 topic
Objects, Constructors, and Methods
- Explain the distinction between a class and an object, and create objects by calling constructors with the new keyword, passing appropriate arguments.
- Call void and return methods on objects, explain the difference between methods that modify state and methods that return values, and use return values in expressions and assignments.
- Apply String class methods (length, substring, indexOf, equals, compareTo) to manipulate and analyze text data, predicting the output of method calls on string objects.
- Use the Math class static methods (abs, pow, sqrt, random) and explain the concept of wrapper classes (Integer, Double) including autoboxing and unboxing between primitives and their wrapper objects.
- Explain the difference between null references and initialized object references, predicting what happens when a method is called on a null reference (NullPointerException).
- Concatenate strings using the + operator and explain how Java converts non-String operands to strings during concatenation, predicting the output of mixed-type concatenation expressions.
3
Unit 3: Boolean Expressions and if Statements
1 topic
Conditionals and Boolean Logic
- Construct boolean expressions using relational operators (==, !=, <, >, <=, >=) and logical operators (&&, ||, !) to represent conditions involving numeric and boolean values.
- Write if, if-else, and if-else-if statements to implement multi-way branching logic, tracing execution paths for given input values.
- Apply De Morgan's laws to simplify compound boolean expressions and identify equivalent conditional structures that produce the same behavior.
- Explain the difference between comparing primitive values with == and comparing object references with == versus the equals method, identifying common errors in object comparison.
- Explain short-circuit evaluation in Java, predicting when the second operand of && and || is not evaluated and how this affects expressions with side effects or potential runtime errors.
- Write nested conditional structures to implement multi-criteria decision logic, tracing execution through all possible paths and verifying that every case is handled correctly.
4
Unit 4: Iteration
1 topic
Loop Structures
- Write while loops and for loops to repeat a block of code, correctly initializing loop variables, specifying termination conditions, and updating loop variables to avoid infinite loops.
- Trace the execution of nested loops, predicting the number of iterations and the output produced for each combination of outer and inner loop iterations.
- Implement standard loop algorithms for computing sums, products, averages, counting occurrences, finding minimum and maximum values, and reversing or manipulating strings character by character.
- Analyze loop constructs to identify common errors including off-by-one errors, infinite loops, and incorrect boundary conditions, and debug or correct the flawed code.
- Write loops that process strings character by character using charAt and length methods to implement algorithms such as counting vowels, checking palindromes, and building new strings.
- Design and implement a loop-based solution for a novel problem by identifying the loop pattern (counting, sentinel, flag-controlled) and translating the algorithm into Java code.
5
Unit 5: Writing Classes
2 topics
Class Design and Encapsulation
- Design a class with private instance variables, a constructor that initializes them, and accessor (getter) and mutator (setter) methods that provide controlled access to the object's state.
- Explain the principle of encapsulation and why instance variables should be declared private, describing how accessor and mutator methods enforce data integrity and information hiding.
- Write the toString method for a class to return a meaningful string representation of an object's state, and explain when Java automatically calls toString.
Static Members and Method Design
- Distinguish between static and non-static variables and methods, explaining when to use each and how static members are shared across all instances of a class.
- Explain scope rules for local variables, parameters, and instance variables, and use the this keyword to distinguish between instance variables and parameters with the same name.
- Design a multi-class program that models a real-world scenario using appropriate class decomposition, method signatures, and object interactions between collaborating classes.
- Implement method overloading by writing multiple methods with the same name but different parameter lists, explaining how Java determines which method to call based on the arguments provided.
- Explain the difference between passing primitive values and passing object references to methods, predicting how modifications within a method affect variables in the calling code.
6
Unit 6: Array
1 topic
Array Fundamentals and Algorithms
- Declare and initialize one-dimensional arrays of primitive types and object references, access elements using index notation, and explain that array indices start at zero.
- Traverse arrays using standard for loops and enhanced for-each loops, explaining when each traversal method is appropriate and the limitations of enhanced for loops for modification.
- Implement common array algorithms including linear search, finding minimum and maximum values, computing sums and averages, counting elements that meet a condition, and shifting or rotating elements.
- Explain ArrayIndexOutOfBoundsException, identify code patterns that cause it, and write defensive code that prevents index-related runtime errors during array operations.
- Implement selection sort and insertion sort algorithms on arrays, tracing the state of the array after each pass and explaining the relative efficiency of each sorting approach.
- Explain that arrays are objects in Java, that array variables hold references, and predict the behavior when arrays are assigned to new variables or passed to methods.
7
Unit 7: ArrayList
1 topic
ArrayList Operations and Algorithms
- Create ArrayList objects with a specified type parameter, and use the add, remove, get, set, and size methods to manipulate the list's contents.
- Traverse an ArrayList using for loops, enhanced for loops, and while loops, correctly handling index shifting when elements are added or removed during traversal.
- Compare arrays and ArrayLists in terms of fixed versus dynamic size, syntax differences, ability to store primitives versus objects, and performance characteristics, selecting the appropriate structure for a given problem.
- Implement algorithms that use ArrayLists to solve problems requiring dynamic collections, including filtering elements based on conditions, inserting in sorted order, and removing duplicates.
- Explain how autoboxing and unboxing allow ArrayList objects declared with wrapper types (Integer, Double) to store and retrieve primitive values seamlessly in Java.
8
Unit 8: 2D Array
1 topic
Two-Dimensional Array Operations
- Declare and initialize two-dimensional arrays, access individual elements using row and column indices, and determine the number of rows and columns in a 2D array.
- Traverse a two-dimensional array using nested for loops in both row-major and column-major order, and use enhanced for loops for 2D array traversal.
- Implement algorithms that process 2D arrays including computing row and column sums, searching for specific values, transposing matrices, and checking for specific patterns in grid data.
- Explain how 2D arrays are stored in Java as arrays of arrays (ragged arrays are possible), and create and traverse 2D arrays where rows may have different lengths.
- Design a solution using a 2D array to model a grid-based problem such as a game board or seating chart, implementing the data structure and required operations.
9
Unit 9: Inheritance
2 topics
Subclasses and Superclasses
- Define inheritance and the IS-A relationship, create subclasses using the extends keyword, and explain how a subclass inherits public methods and instance variables from its superclass.
- Write subclass constructors that call the superclass constructor using super() and explain the rules governing constructor chaining in Java inheritance hierarchies.
- Override methods in a subclass to provide specialized behavior, using the super keyword to call the superclass version, and explain the rules for valid method overriding versus overloading.
Polymorphism
- Explain polymorphism and how a superclass reference variable can refer to a subclass object, predicting which version of an overridden method will execute at runtime based on the actual object type.
- Explain the Object class as the root of the Java class hierarchy and override its toString and equals methods to provide meaningful behavior for custom classes.
- Design an inheritance hierarchy for a given problem domain, deciding which methods to override, which to inherit, and how polymorphism enables flexible and extensible code.
- Write code that uses polymorphism to process an ArrayList of superclass-type references containing mixed subclass objects, calling overridden methods that dispatch to the correct subclass implementation.
- Distinguish between compile-time type and runtime type of an object reference, predicting which methods are accessible based on the declared type and which implementation executes based on the actual type.
10
Unit 10: Recursion
1 topic
Recursive Methods
- Define recursion and identify the base case and recursive case in a recursive method, explaining how the call stack manages recursive method invocations.
- Trace the execution of recursive methods by drawing the call stack and tracking parameter values, return values, and the order of method calls and returns.
- Implement recursive solutions for standard problems including factorial, Fibonacci, binary search, and merge sort, identifying the base case, recursive case, and how the problem size decreases.
- Compare recursive and iterative solutions to the same problem, evaluating tradeoffs in readability, memory usage (stack depth), and efficiency, and convert between the two approaches.
- Implement recursive methods that process strings and arrays by reducing the problem size on each call, such as reversing a string, checking for palindromes, or computing the sum of array elements.
- Identify and explain the concept of merge sort as a divide-and-conquer recursive sorting algorithm, tracing the splitting and merging phases for a small array.
Scope
Included Topics
- All ten units of the AP Computer Science A course framework (College Board, effective 2020-present): Unit 1 Primitive Types, Unit 2 Using Objects, Unit 3 Boolean Expressions and if Statements, Unit 4 Iteration, Unit 5 Writing Classes, Unit 6 Array, Unit 7 ArrayList, Unit 8 2D Array, Unit 9 Inheritance, Unit 10 Recursion.
- Primitive types: int, double, and boolean data types, arithmetic operators, type casting, assignment operators, compound assignment operators, increment and decrement operators, and the distinction between integer and floating-point division.
- Using objects: creating objects using constructors, calling methods (void and return), String class methods (length, substring, indexOf, compareTo, equals), wrapper classes (Integer, Double), autoboxing and unboxing, and the Math class (abs, pow, sqrt, random).
- Boolean expressions and control flow: boolean operators (and, or, not), relational operators, if, if-else, and if-else-if statements, nested conditionals, compound boolean expressions, short-circuit evaluation, De Morgan's laws, and comparing objects versus primitives.
- Iteration: while loops, for loops, do-while loop equivalents, nested loops, loop analysis (counting iterations, tracing output), String traversal using loops, and common loop algorithms (sum, min, max, average, counting).
- Writing classes: class design with instance variables (private), constructors, accessor and mutator methods, the this keyword, static variables and methods, scope and access, method overloading, and the toString method.
- Arrays: one-dimensional arrays, array creation and access, traversal with for and enhanced for loops, common array algorithms (search, sort, accumulate), passing arrays to methods, and array index out of bounds exceptions.
- ArrayList: ArrayList class methods (add, remove, get, set, size), traversal and modification, autoboxing with ArrayList, converting between arrays and ArrayLists, and the difference between arrays and ArrayLists.
- Two-dimensional arrays: 2D array creation, traversal using nested loops (row-major and column-major order), and common 2D array algorithms.
- Inheritance: superclass and subclass relationships, extends keyword, method overriding, super keyword for constructors and methods, polymorphism, Object class (toString, equals), abstract classes concept, and the IS-A relationship.
- Recursion: recursive method design, base case and recursive case, tracing recursive calls, recursive algorithms (factorial, Fibonacci, binary search, merge sort), and comparing recursive and iterative approaches.
- Exam-aligned skills including code tracing, code writing, code analysis, and computational thinking as tested in AP Computer Science A free-response and multiple-choice questions.
Not Covered
- Data structures beyond arrays and ArrayLists (linked lists, stacks, queues, trees, hash tables, graphs) covered in AP Computer Science AB or college data structures courses.
- GUI programming, event-driven programming, and JavaFX/Swing beyond the scope of the AP CSA framework.
- File I/O, exception handling with try-catch blocks, and multithreading beyond basic conceptual understanding.
- Advanced Java features including generics (beyond ArrayList), lambda expressions, streams, interfaces (beyond conceptual understanding), and enums.
- Software engineering practices (design patterns, version control, testing frameworks, deployment) beyond basic class design.
Official Exam Page
Learn more at College Board
AP-CSA is coming soon
Adaptive learning that maps your knowledge and closes your gaps.
Create Free Account to Be Notified