2.4 If-Else Statements

TLDR

Nested if statements put decisions inside other decisions, so the inner condition only gets checked when the outer condition is true. They also include multiway selection with if-else-if chains, where the program runs the code for the first condition that is true and skips the rest. In AP Computer Science A, you use this pattern to model layered logic and to predict exactly which branch runs.

more resources to help you study

practice multiple choiceFRQ practice & scoringcheatsheetsscore calculator

How Do Nested if Statements Work?

A nested if statement places one decision inside another, so the inner condition is evaluated only after the outer condition is true. An if-else-if chain is multiway selection: Java checks conditions in order and runs at most one branch, the first one whose condition is true.

Why This Matters for the AP Computer Science A Exam

Selection and iteration make up a large share of the exam, and nested branching shows up in both reading and writing code. On the multiple-choice section, you trace nested conditions to determine output or to pick the missing code that completes a described task. On free-response code writing, you build methods that need layered decisions, such as checking one thing first and only then checking a second condition. Getting comfortable with how nesting and if-else-if chains flow helps you avoid the most common tracing mistakes.

Key Takeaways

• Nested if statements are if, if-else, or if-else-if statements placed inside another if, if-else, or if-else-if statement.
• The inner condition is evaluated only when the outer condition is true. If the outer is false, the inner is skipped entirely.
• In an if-else-if (multiway selection), at most one block runs, and it is the block for the first condition that evaluates to true.
• A trailing else runs only when none of the earlier conditions are true.
• Order matters in if-else-if chains: check the most specific or most restrictive condition first so a broader condition does not catch a value early.
• Trace nested logic line by line with sample inputs to confirm which branch actually executes.

How Nested if Statements Work

Inner conditions depend on outer conditions

Nesting means one selection statement lives inside the body of another. The inner Boolean expression is only checked when the outer Boolean expression is true. If the outer condition is false, the program never looks at the inner condition.

</>Java
if (isValidUsername(username)) {
    // Only checked because the username was valid
    if (isValidPassword(password)) {
        System.out.println("Access granted!");
    } else {
        System.out.println("Password incorrect");
    }
} else {
    System.out.println("Username not found");
}

Here the password check only happens when the username is valid. That is the whole point of nesting: you handle a primary decision first, then a secondary decision that only matters in certain cases.

Multiway selection with if-else-if

When you need a series of conditions where exactly one path should run, use an if-else-if chain. The program evaluates conditions in order and runs the block for the first one that is true. Once a true condition is found, the rest are skipped. A trailing else catches everything that did not match.

</>Java
if (score >= 90) {
    grade = "A";
} else if (score >= 80) {
    grade = "B";
} else if (score >= 70) {
    grade = "C";
} else if (score >= 60) {
    grade = "D";
} else {
    grade = "F";
}

Notice you do not need to write score < 90 && score >= 80 for the B branch. Because the A branch already handled scores of 90 and up, reaching the B branch already guarantees the score is below 90. This is what makes if-else-if chains clean: each later condition assumes all earlier ones were false.

Condition order changes the result

Because only the first true condition runs, the order of conditions matters. If you put a broad condition first, it can catch values meant for a more specific branch.

</>Java
// Wrong order: score of 95 prints "C"
int score = 95;
if (score >= 70) {
    System.out.println("C");
} else if (score >= 80) {
    System.out.println("B");   // never reached
} else if (score >= 90) {
    System.out.println("A");   // never reached
}

// Correct order: most specific first
if (score >= 90) {
    System.out.println("A");
} else if (score >= 80) {
    System.out.println("B");
} else if (score >= 70) {
    System.out.println("C");
} else {
    System.out.println("F");
}

Combining nesting and chaining

You can nest an if-else-if chain inside another selection statement when a layered decision has multiple categories. For example, validate an input first, and only classify it when it is valid.

</>Java
public static boolean validateAge(int age) {
    if (age >= 0 && age <= 120) {
        // Valid: now classify into a category
        if (age < 13) {
            System.out.println("Child");
        } else if (age < 20) {
            System.out.println("Teenager");
        } else if (age < 65) {
            System.out.println("Adult");
        } else {
            System.out.println("Senior");
        }
        return true;
    } else {
        // Invalid: give a specific reason
        if (age < 0) {
            System.out.println("Age cannot be negative");
        } else {
            System.out.println("Age seems unrealistic");
        }
        return false;
    }
}

The inner classification only runs after the outer validity check passes. This mirrors how a lot of exam methods are structured: guard the input, then branch on the details.

How to Use This on the AP Computer Science A Exam

Code Tracing

When you trace nested conditions, evaluate the outer condition first. If it is false, skip the entire inner block and jump to the matching else. For if-else-if chains, check each condition in order and stop at the first true one. A frequent trap on multiple-choice is assuming more than one branch runs in a chain, or assuming the inner condition is checked even when the outer is false. Only one path through an if-else-if chain executes.

Free Response

On free-response code writing, you often need a method that makes layered decisions. Read the specification closely and underline return types, parameters, and any condition keywords. Decide which check is the primary decision and which checks only matter afterward, then nest accordingly. Make sure every input has a defined outcome, including the case where no condition is true, so you do not accidentally fall through with nothing happening.

Common Trap

Watch out for condition order in chains. If a broad condition such as score >= 70 comes before score >= 90, the broad one runs first and the specific branch is unreachable. Order from most restrictive to least restrictive.

Worked Examples

Layered transaction logic

This method checks the amount first, then branches on the transaction type, and nests a funds check inside the withdraw path.

</>Java
public static double processTransaction(double balance, String type, double amount) {
    double newBalance = balance;

    if (amount < 0) {
        System.out.println("Error: amount cannot be negative");
        return balance;
    }

    if (type.equals("deposit")) {
        newBalance = balance + amount;
    } else if (type.equals("withdraw")) {
        if (balance >= amount) {
            newBalance = balance - amount;
        } else {
            System.out.println("Insufficient funds");
        }
    } else {
        System.out.println("Invalid transaction type: " + type);
    }

    return newBalance;
}

The withdraw branch shows nesting clearly: the funds check only happens after the type is confirmed to be a withdrawal.

Student status classifier

</>Java
public static void classifyStudent(int credits, String name) {
    if (credits < 0) {
        System.out.println("Error: credits cannot be negative");
        return;
    }

    String status;
    if (credits >= 90) {
        status = "Senior";
    } else if (credits >= 60) {
        status = "Junior";
    } else if (credits >= 30) {
        status = "Sophomore";
    } else {
        status = "Freshman";
    }

    System.out.println(name + " is a " + status);

    if (credits >= 120) {
        System.out.println("Eligible for graduation");
    } else {
        System.out.println("Credits needed: " + (120 - credits));
    }
}

The year classification uses multiway selection, and the graduation check is a separate two-way decision after it.

Common Misconceptions

• The inner condition is always checked. It is not. The inner Boolean expression is only evaluated when the outer condition is true.
• More than one branch in an if-else-if chain can run. Only one block executes, the one for the first condition that is true.
• The else matches the closest if only if you do not use braces carefully. Use braces to make grouping clear so the else pairs with the intended if.
• Condition order in a chain does not matter. It does. A broader condition placed first can make later, more specific conditions unreachable.
• You must repeat the opposite of earlier conditions in later branches. You do not. Reaching a later branch already guarantees every earlier condition was false.
• A missing trailing else is always fine. If no condition is true and there is no else, none of the blocks run, which can leave a value unset or a case unhandled.

Related AP Computer Science A Guides

• 2.1 Algorithms with Selection and Repetition
• 2.2 Boolean Expressions
• 2.3 If Statements and Control Flow
• 2.5 Compound Boolean Expressions
• 2.7 While Loops
• 2.6 Equivalent Boolean Expressions
• 2.11 Nested Iteration
• 2.12 Informal Code Analysis
• 2.8 For Loops