Introduction: Decisions Within Decisions

In the previous chapters, we learned how to use a single if statement to make a choice. But in the real world, decisions aren't always that simple. Often, one decision depends on the outcome of another. For example, if it is raining, you decide to stay inside; if you are staying inside, you then decide if you should read a book or watch a movie. In Java, we handle these "layered" decisions using Nested if Statements.

By the end of these notes, you will be able to write and trace complex selection structures where one if statement lives inside another!

What is a Nested if Statement?

A nested if statement is simply an if statement that is placed inside the body of another if statement. You can think of this like a "room within a room." You can only see what is in the inner room if you have already successfully entered the outer room.

The Basic Structure:

if (outerCondition) {
    // This code runs if outerCondition is true
    if (innerCondition) {
        // This code runs ONLY if BOTH are true
    }
}

Key Rule: The inner if statement is only ever evaluated if the outer if statement's condition is \( \text{true} \). If the outer condition is \( \text{false} \), the computer skips the entire block, including the inner if.

Real-World Analogy: The Movie Theater

Imagine you are trying to watch an R-rated movie:

1. Outer If: Do you have a ticket? (\( \text{hasTicket} == \text{true} \))
2. Inner If: Are you 17 or older? (\( \text{age} \geq 17 \))

If you don't have a ticket, the theater staff won't even bother checking your ID! The second check only happens if the first check passes.

Key Takeaway

Nested if statements allow for more specific logic. They create a hierarchy where the "inner" logic is protected by the "outer" logic.

Tracing Nested Logic

Tracing is a vital skill for Section I (Multiple-choice) of the AP Exam. When you trace nested statements, follow the flow step-by-step.

Consider this code segment:

\( \text{int } x = 10; \)
\( \text{int } y = 5; \)

if (\( x > 0 \)) {
    if (\( y > 0 \)) {
        System.out.println("Both are positive");
    }
}

Step-by-Step Execution:

  1. Check the outer condition: Is \( x > 0 \)? Yes (\( 10 > 0 \) is \( \text{true} \)).
  2. Enter the outer block.
  3. Check the inner condition: Is \( y > 0 \)? Yes (\( 5 > 0 \) is \( \text{true} \)).
  4. Execute the print statement.

What if \( x \) was \( -1 \)?
The outer condition (\( -1 > 0 \)) would be \( \text{false} \). The program would skip the entire block and nothing would be printed, even if \( y \) was still positive.

The "Dangling Else" Problem

One of the most common mistakes in AP Computer Science A is misidentifying which if an else belongs to. This is often called the dangling else.

The Rule: In Java, an else always matches with the closest preceding if statement that is in the same block and does not already have an else.

Example Trace:

if (\( a > 5 \))
    if (\( b > 5 \))
        System.out.println("Path A");
else
    System.out.println("Path B");

Even though the else is aligned with the first if, Java ignores indentation! The else actually belongs to the if (\( b > 5 \)). If \( a = 10 \) and \( b = 2 \), the output would be "Path B". If \( a = 2 \), nothing would happen because the outer if failed.

Pro-Tip: Always use curly braces { } to make your code clear. Braces force the else to belong to the if you intend!

Quick Comparison: Nested vs. Compound

Sometimes you can achieve the same result using a Compound Boolean Expression (Topic 2.5) with the AND operator (\( \&\& \)).

Nested:
if (conditionA) { if (conditionB) { ... } }

Compound:
if (conditionA && conditionB) { ... }

While they often behave similarly, nested if statements are better when you want to execute specific code after the first check fails, or if you have multiple different "inner" checks to perform.

Common Mistakes to Avoid

  • Wrong "Else" Logic: Assuming an else belongs to the outer if when it actually belongs to the inner one.
  • Missing Braces: Forgetting { } when you have multiple lines of code inside an if statement.
  • Confusing \( == \) and \( = \): Remember, \( == \) is for comparing (selection), while \( = \) is for assigning values.

Quick Review

1. When does the inner if execute?
Only when the outer if condition evaluates to \( \text{true} \).

2. How does Java match an else?
It matches the nearest unpaired if above it in the same code block.

3. Why use nesting?
To create complex, multi-stage decision logic that a single if cannot handle.

Key Takeaway

Nested if statements are the "logic trees" of computer science. Mastering how to trace them is essential for success on both the Multiple-choice and Free-response sections of the AP Exam.