# AP Computer Science A (AP CSA)

## Course Overview

AP Computer Science A is an introductory college-level computer science course focused heavily on computing fundamentals, algorithmic logic, and object-oriented programming. Students learn how to design, implement, and analyze solutions to complex problems using the Java programming language.

The curriculum focuses on code execution correctness, structuring code for reusability, understanding object-oriented relationships, and managing data structures.

* **Target Grade:** 10th–12th Grade
* **Prerequisites:** Algebra I & basic logic familiarity
* **Primary Programming Language:** Java (strictly mandated by College Board)
* **AP Assessment Structure:**
  * 50% Multiple-Choice Section (40 questions)
  * 50% Free-Response Section (4 handwritten code questions: Methods/Control Structures, Classes, 1D Arrays/ArrayLists, and 2D Arrays)

---

## Curricular Units (Agnostic to Time & Schedule)

### Unit 1: Primitive Types
* **Core Concepts:** Variable declarations and assignments; data types (`int`, `double`, `boolean`); arithmetic expressions and operators; compound assignment operators; casting and literal values.
* **Key Learning Outcome:** Understanding how Java stores data in memory and how to perform basic math operations using code.

### Unit 2: Using Objects
* **Core Concepts:** Instances and object creation; calling methods with and without parameters; return values; the `String` class (concatenation, literals, immutability); String methods; the `Math` class; Wrapper classes (`Integer`, `Double`).
* **Key Learning Outcome:** Shifting from basic variables to initializing and manipulating object references.

### Unit 3: Boolean Expressions and `if` Statements
* **Core Concepts:** Relational operators; conditional statements (`if`, `if-else`, nested conditionals); Boolean expressions and logical operators (`&&`, `||`, `!`); De Morgan's Laws; object reference comparison vs. value comparison (`.equals()` vs `==`).
* **Key Learning Outcome:** Directing program flow and creating complex logical decision paths.

### Unit 4: Iteration
* **Core Concepts:** `while` loops; `for` loops; string processing using iteration; nested loops; code blocks and infinite loop prevention.
* **Key Learning Outcome:** Automating repetitive calculations and algorithm paths efficiently.

### Unit 5: Writing Classes
* **Core Concepts:** Anatomy of a class; public vs. private visibility; instance variables; constructors (overloading, parameters); documentation; writing accessor and mutator methods; the `this` keyword; static variables and methods; variable scope.
* **Key Learning Outcome:** Designing data blueprints and understanding structural encapsulation.

### Unit 6: Array (1D Arrays)
* **Core Concepts:** Initializing and traversing 1D arrays; indexing; enhanced `for` loops (for-each loops); fundamental array algorithms (finding min/max, calculating averages, reversing elements).
* **Key Learning Outcome:** Managing simple linear collections of data.

### Unit 7: `ArrayList`
* **Core Concepts:** Declaring and manipulating `ArrayList` collections; using the `List` interface methods (`add`, `get`, `set`, `remove`, `size`); traversing `ArrayList` collections; sorting and searching datasets; handling `ConcurrentModificationException`.
* **Key Learning Outcome:** Dynamically sizing data collections to handle scalable information tracking.

### Unit 8: 2D Array
* **Core Concepts:** Initializing 2D array grids; row-major vs. column-major indexing; nested loops for grid traversal; spatial data processing algorithms.
* **Key Learning Outcome:** Representing matrices, grids, game boards, and tabular layouts in memory.

### Unit 9: Inheritance
* **Core Concepts:** Superclasses and subclasses; creating class hierarchies using `extends`; overriding methods; the `super` keyword; constructors in subclasses; polymorphism; the `Object` class inheritance.
* **Key Learning Outcome:** Reusing code layers and creating hierarchical object logic ecosystems.

### Unit 10: Recursion
* **Core Concepts:** Tracing recursive methods; base cases vs. recursive calls; recursive binary search algorithms; merge sort logic.
* **Key Learning Outcome:** Solving structural problems by dividing them into smaller, repeating instances of themselves.

---

## Course & Grading Metrics

Because this course mimics a first-semester university programming class, assessment categories focus heavily on code execution and architectural validity:

* **40% Formal Examinations** (targeting AP Multiple-Choice style logic)
* **30% Free-Response Programming Labs** (handwritten and IDE-compiled Java code)
* **20% Practical Project Portfolios** (case studies and standalone programs)
* **10% Daily Code Tracing Exercises & Quizzes**