AP Computer Science A
Unit 2: Selection and Iteration
8 topics to cover in this unit
Watch Video
AI-generated review video covering all topics
Watch NowStudy Notes
Follow-along note packet with fill-in-the-blank
Start NotesTake Quiz
20 AP-style questions to test your understanding
Start QuizUnit 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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.
- Jumping straight to code without planning the algorithm
- Not testing algorithms with edge cases
- Confusing the algorithm concept with its specific implementation
Key Terms
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