3.4 Else If Statements

Introduction

So far, we've explored if statements for one-way selection and if-else statements for two-way selection. But what happens when you need to check multiple conditions and take different actions based on which condition is true? This is where else if statements come in, allowing us to implement multi-way selection. Multi-way selection lets us create more sophisticated decision trees in our code, enabling our programs to handle a variety of situations with elegant, readable logic.

What is Multi-Way Selection?

Multi-way selection is a control structure that allows a program to choose between three or more alternative actions based on different conditions. In Java, this is accomplished using if-else-if statements (often called an "else if ladder" or "if-else-if chain").

Important terms to know:

• Condition1: a logical expression that is evaluated to determine if a certain action should be taken. It is typically used in control structures like if statements and loops.
• Condition2: a logical expression that helps determine whether an action should be executed based on specific criteria.
• Condition3: a logical expression that helps determine whether certain actions should be performed based on specific conditions being met.

if (condition1) {
    // Code executed when condition1 is true
} else if (condition2) {
    // Code executed when condition1 is false AND condition2 is true
} else if (condition3) {
    // Code executed when condition1 and condition2 are false AND condition3 is true
} else {
    // Code executed when all conditions are false
}

Syntax and Structure

The else if statement combines elements of both if and else statements. Each else if provides another condition to check if the previous conditions were false.

Key components:

• An initial if statement with the first condition
• One or more else if clauses, each with their own condition
• An optional final else clause that executes when all conditions are false

How else if Statements Work

When Java encounters an if-else-if statement:

1. It evaluates the first condition (after the initial if)
2. If that condition is true, it executes the associated code block and skips all remaining conditions
3. If that condition is false, it moves to the next condition (after the first else if)
4. It continues this process until either:
   • A condition evaluates to true (and its code block executes)
   • All conditions are false (and the final else block executes, if present)
5. Only one code block in the entire chain will execute

Example: Grading System

int score = 85;
char grade;

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';
}

System.out.println("Your grade is: " + grade);

In this example:

• If score is 95, the grade will be 'A'
• If score is 85, the grade will be 'B'
• If score is 75, the grade will be 'C'
• If score is 65, the grade will be 'D'
• If score is 55, the grade will be 'F'

Note that only one grade is assigned, and the program executes exactly one of the code blocks.

Condition Evaluation Order

The order of conditions in an else if chain is critical. Java evaluates conditions from top to bottom and executes the code block for the first condition that evaluates to true.

int num = 5;

// Example 1: Correct order (most specific to most general)
if (num == 5) {
    System.out.println("Number is 5");
} else if (num > 0) {
    System.out.println("Number is positive");
} else {
    System.out.println("Number is negative or zero");
}
// Output: "Number is 5"

// Example 2: Problematic order (most general to most specific)
if (num > 0) {
    System.out.println("Number is positive");
} else if (num == 5) {
    System.out.println("Number is 5"); // This will never execute for num = 5!
} else {
    System.out.println("Number is negative or zero");
}
// Output: "Number is positive"

In Example 2, the code block for num == 5 will never execute when num is 5 because the first condition num > 0 already evaluates to true.

Comparison of Selection Structures

Real-World Examples

Example 1: Weather Advice

int temperature = 75;

if (temperature > 90) {
    System.out.println("It's hot! Stay hydrated and limit outdoor activities.");
} else if (temperature > 70) {
    System.out.println("It's warm. Enjoy the pleasant weather!");
} else if (temperature > 50) {
    System.out.println("It's cool. Consider bringing a light jacket.");
} else if (temperature > 32) {
    System.out.println("It's cold. Wear a coat and gloves.");
} else {
    System.out.println("It's freezing! Stay warm and be cautious of ice.");
}

Example 2: Calculating Tax Brackets

double income = 65000.0;
double tax;

if (income <= 9950) {
    tax = income * 0.10;
} else if (income <= 40525) {
    tax = 995 + (income - 9950) * 0.12;

} else if (income <= 86375) {
    tax = 4664 + (income - 40525) * 0.22;

} else if (income <= 164925) {
    tax = 14751 + (income - 86375) * 0.24;

} else if (income <= 209425) {
    tax = 33603 + (income - 164925) * 0.32;

} else if (income <= 523600) {
    tax = 47843 + (income - 209425) * 0.35;

} else {
    tax = 157804.25 + (income - 523600) * 0.37;

}

System.out.println("Your estimated tax is: $" + tax);

Tips and Best Practices

1. Order your conditions from most specific to most general

This prevents earlier, more general conditions from "shadowing" later, more specific ones.

2. Ensure that all possible cases are handled

Either make sure your conditions cover all possibilities or include a final else clause as a catch-all.

3. Keep conditions simple and readable

If conditions become complex, consider breaking them down or using helper methods.

// Instead of this:
if (score >= 90 && !extraCredit && studentPresent) {
    // ...
}

// Consider this:
boolean qualifiesForA = score >= 90 && !extraCredit && studentPresent;
if (qualifiesForA) {
    // ...
}

4. Use proper indentation and formatting

Consistent indentation makes the code structure clearer, especially with multiple conditions.

if (condition1) {
    // code
} else if (condition2) {
    // code
} else if (condition3) {
    // code
} else {
    // code
}

5. Consider using switch statements for certain scenarios

When checking a single variable against multiple exact values, a switch statement might be cleaner.

Common Pitfalls

1. Incorrect order of conditions

int age = 16;

// Problematic (less specific condition first)
if (age > 0) {
    System.out.println("Valid age");
} else if (age >= 16) {
    System.out.println("Can drive"); // Never reached for age=16
}

// Correct (more specific condition first)
if (age >= 16) {
    System.out.println("Can drive");
} else if (age > 0) {
    System.out.println("Valid age, but too young to drive");
}

2. Missing final else clause

Without a final else, your code might silently handle unexpected cases without any feedback.

int month = 15; // Invalid month

// Without final else - silent failure for invalid input

if (month == 12 || month <= 2) {
    season = "Winter";
} else if (month <= 5) {
    season = "Spring";
} else if (month <= 8) {
    season = "Summer";
} else if (month <= 11) {
    season = "Fall";
}
// No error message for month=15!

// With final else - catches unexpected input

if (month == 12 || month <= 2) {
    season = "Winter";
} else if (month <= 5) {
    season = "Spring";
} else if (month <= 8) {
    season = "Summer";
} else if (month <= 11) {
    season = "Fall";
} else {
    System.out.println("Error: Invalid month number");
    season = "Unknown";
}

3. Forgetting that only one block executes

Remember that in an if-else-if chain, only the first matching condition will have its code block executed.

Key Takeaways

• else if statements enable multi-way selection, allowing code to choose between multiple paths
• Only one code block in the entire if-else-if chain will execute
• Conditions are evaluated in order from top to bottom
• Always order conditions from most specific to most general