Topic Outline for Advanced Placement Computer Science

Topics covered by the course include:
    Object-Oriented Program Design
        Problem Design
            Read and understand a problem's description, purpose, and goals.
            Specify the purpose and goals for a problem. (AB only)
            Apply data abstraction and encapsulation.
            Read and understand class specifications and relationships among the classes ("is-a", "has-a" relationships).
            Decompose a problem into classes, define relationships and responsibilities of those classes. (AB only)
            Understand and implement a given class hierarchy.
            Identify reusable components from existing code using classes and class libraries.
        Class Design
            Design and implement a class.
            Design and implement a set of interacting classes. (AB only)
            Design an interface.
            Choose appropriate data representation and algorithms.
            Choose appropriate advanced data structures and algorithms. (AB only)
            Apply functional decomposition.
            Extend a given class using inheritance.
    Program Implementation
        Implementation techniques
            Methodology
                Object-oriented development
                Top-down development
                Encapsulation and information holding
                Procedural abstraction
        Programming constructs
            Primitive types vs. objects
            Declaration
                Constant declarations
                Variable declarations
                Class declarations
                Interface declarations
                Method declarations
                Parameter declarations
            Console output (System.out.print/println)
            Control
                Methods
                Sequential
                Conditional
                Iterations
                Recursion
        Java library classes (included in the A or AB-level AP Java Subset)
    Program Analysis
        Testing
            Test classes and libraries in isolation
            Identify boundary cases and generate appropriate test data
            Perform integration testing
        Debugging
            Categorize errors: compile time, runtime, logic
            Identify and correct errors
            Techniques: use a debugger, add extra output statements, hand-trace code
        Understand and modify existing code
        Extend existing code using inheritance
        Understand error handling
            Understand runtime exceptions
            Throw runtime exceptions (AB only)
        Reason about programs
            Preconditions and postconditions
            Assertions
            Invariants (AB only)
        Analysis of algorithms
            Informal comparisons of running times
            Exact calculation of statement execution counts
            Big-O notation (AB only)
            Worst-case and average-case time and space analysis (AB only)
        Numerical representations and limits
            Representations of numbers in different bases
            Limitations of finite representations (e.g., integer bounds, imprecision of floating-point representations, and round-off error)
    Standard Data Structures
        Simple data types (int, boolean, double)
        Classes
        One-dimensional arrays
        Two-dimensional arrays
        Linked lists (singly, doubly, circular) (AB only)
        Stacks (AB only)
        Queues (AB only)
        Trees (AB only)
        Heaps (AB only)
        Priority queues (AB only)
        Sets (AB only)
        Maps (AB only)
    Standard Algorithms
        Operations on data structures listed above
            Traversals
            Insertions
            Deletions
            Iterators (AB only)
        Searching
            Sequential
            Binary
            Hashing (AB only)
        Sorting
            Selection
            Insertion
            Mergesort
            Quicksort (AB only)
            Heapsort (AB only)
    Computing in Context
        Major hardware components
            Primary and secondary memory
            Processors
            Peripherals
        System software
            Language translators/compilers
            Virtual machines
            Operating systems
        Types of systems
            Single-user systems
            Networks
        Responsible use of computer systems
            System reliability
            Privacy
            Legal issues and intellectual property
            Social and ethical ramifications of computer use