AP Computer Science A

Unit 2: Selection and Iteration

8 topics to cover in this unit

Unit Progress0%

Watch Video

AI-generated review video covering all topics

Watch Now

Study Notes

Follow-along note packet with fill-in-the-blank

Start Notes

Take Quiz

20 AP-style questions to test your understanding

Start Quiz

Unit Outline

Boolean Expressions and if Statements

Understanding how to create logical conditions using boolean expressions and control program flow with if statements. Students learn to evaluate conditions and execute code blocks based on true/false outcomes.

Program Design and Algorithm DevelopmentCode Logic

Common Misconceptions

Confusing assignment (=) with equality (==)
Thinking that if statements always need an else clause
Misunderstanding operator precedence in complex boolean expressions

if Statements and Control Flow

Expanding on basic if statements to include else-if chains and nested conditionals. Students learn to create branching logic that handles multiple conditions and creates sophisticated decision-making structures.

Program Design and Algorithm DevelopmentCode LogicCode Implementation

Common Misconceptions

Writing unreachable code after if-else chains
Forgetting that only one branch executes in if-else-if chains
Creating unnecessarily complex nested structures when simpler logic would work

Comparing Objects

Understanding the difference between comparing primitive values and object references. Students learn when to use == versus .equals() method and how object comparison works in Java.

Program Design and Algorithm DevelopmentCode Logic

Common Misconceptions

Using == to compare String content instead of .equals()
Assuming == works the same for primitives and objects
Forgetting to check for null before calling .equals()

Compound Boolean Expressions

Creating complex logical conditions using AND (&&), OR (||), and NOT (!) operators. Students learn to combine multiple boolean expressions and understand short-circuit evaluation.

Program Design and Algorithm DevelopmentCode Logic

Common Misconceptions

Confusing && with & and || with |
Not understanding short-circuit evaluation behavior
Writing overly complex compound expressions that are hard to read and debug

Equivalent Boolean Expressions

Learning to recognize and create logically equivalent boolean expressions using De Morgan's Laws and other logical equivalencies. Students practice simplifying and transforming boolean logic.

Program Design and Algorithm DevelopmentCode LogicCode Analysis

Common Misconceptions

Incorrectly applying De Morgan's Laws
Assuming that different-looking expressions can't be equivalent
Not recognizing when boolean expressions can be simplified

Comparing Floating-Point Numbers

Understanding the challenges of comparing floating-point numbers due to precision limitations. Students learn techniques for safely comparing double and float values.

Program Design and Algorithm DevelopmentCode Logic

Common Misconceptions

Using == to compare floating-point numbers directly
Not understanding why 0.1 + 0.2 != 0.3 in computer arithmetic
Choosing inappropriate epsilon values for tolerance comparisons

while Loops

Introduction to iteration using while loops for repeated execution of code blocks. Students learn to create loop conditions and understand loop control flow.

Program Design and Algorithm DevelopmentCode ImplementationCode Logic

Common Misconceptions

Creating infinite loops by forgetting to modify the loop condition variable
Confusing loop entry conditions with loop continuation conditions
Not understanding that loop bodies may execute zero times

Algorithms in Code

Implementing common algorithms using selection and iteration structures. Students practice translating algorithmic thinking into working code using loops and conditionals.

Program Design and Algorithm DevelopmentCode ImplementationCode Analysis

Common Misconceptions

Jumping straight to code without planning the algorithm
Not testing algorithms with edge cases
Confusing the algorithm concept with its specific implementation

Key Terms

boolean expressionrelational operatorslogical operatorsif statementconditional executionelse statementelse-if statementnested conditionalscontrol flowbranchingreference equalityobject equality.equals() method== operatornull referencelogical AND (&&)logical OR (||)logical NOT (!)short-circuit evaluationcompound conditionsDe Morgan's Lawslogical equivalenceboolean algebranegationdistributive propertyfloating-point precisionepsilon comparisonrounding errorsdouble precisiontolerancewhile looploop conditioniterationloop bodyinfinite loopalgorithm implementationpseudocodeloop invariantsalgorithm efficiencystep-by-step process

Key Concepts

Boolean expressions evaluate to true or false and control program execution
Relational and logical operators can be combined to create complex conditions
Control structures allow programs to make decisions and execute different code paths
Nested conditionals can handle complex multi-level decision making
Primitive types use == for value comparison while objects typically use .equals() for content comparison
Understanding reference vs. value equality is crucial for proper object comparison
Logical operators can combine multiple boolean expressions into complex conditions
Short-circuit evaluation can improve efficiency and prevent errors
Multiple boolean expressions can be logically equivalent and produce the same results
De Morgan's Laws provide systematic ways to transform boolean expressions
Floating-point arithmetic can introduce small errors that make exact equality comparisons unreliable
Tolerance-based comparison using epsilon values provides more reliable floating-point comparisons
while loops repeat code execution as long as a boolean condition remains true
Proper loop design requires careful attention to condition changes to avoid infinite loops
Algorithms can be systematically implemented using selection and iteration control structures
Good algorithm design considers both correctness and efficiency

Cross-Unit Connections

Unit 1: Boolean expressions build on primitive data types and operators learned in Unit 1
Unit 3: Loops are essential for array processing and manipulation covered in Unit 3
Unit 4: Selection and iteration are fundamental to string processing algorithms in Unit 4
Unit 5: Object-oriented design often requires selection logic in methods and iteration in constructors
Unit 6: ArrayList algorithms developed here extend to more complex data structure operations
Unit 7: Recursion in Unit 7 provides an alternative to iteration for repetitive processes
Unit 8: Sorting and searching algorithms heavily rely on nested iteration and complex selection logic
Unit 9: Inheritance hierarchies often use selection statements to determine object behavior
Unit 10: Two-dimensional arrays require nested iteration concepts for traversal and processing

Unit 1: Using Objects and Methods Unit 3: Class Creation