Nested if Statements

A thermostat app should print “Comfortable” when the room is between 60 and 80 degrees, counting both ends. That is really two questions: is the temperature at least 60, and is it at most 80? Every Boolean expression you know from Topic 2.2 asks only one question, such as temperature >= 60. With the tools you have so far, how can a program act only when two things are both true?

Think about how a person checks. First they ask “Is it at least 60?” If the answer is no, they stop: the room is too cold, and there is no point asking the second question. Only if the answer is yes do they go on to ask “Is it at most 80?” The second question is asked inside the “yes” answer to the first.

Java lets you write exactly that. In Topic 2.3 you saw that the body of an if statement can hold any statements. An if statement is itself a statement, so it can go inside another if statement’s body. A nested if statement is an if or if-else statement placed inside the body of another one. (In 2.4.4 you will meet a third kind of selection statement that can be nested the same way.) The one on the outside is the outer if statement; the one inside its body is the inner if statement.

int temperature = 72;
if (temperature >= 60)
{
    if (temperature <= 80)
    {
        System.out.println("Comfortable");
    }
}
System.out.println("Check done");

Comfortable
Check done

Now change only the value and watch which lines Java even looks at:

The 50 row is the important one. When the outer condition is false, Java skips the entire outer body, and the inner if is part of that body. So the inner condition is not evaluated at all; it is not checked and found false, it is simply never reached. The 60 row shows the boundary: >= includes 60, so 60 counts as comfortable.

Why “never evaluated” matters

That rule is not just a detail of tracing. You can use it to protect a check that would crash. Recall from Topic 1.3 that dividing an int by zero stops the program with an ArithmeticException. Suppose a gradebook should print “Honor roll” when a student’s average quiz score is at least 80, but a new student has taken zero quizzes:

int totalPoints = 255;
int quizCount = 0;
if (quizCount != 0)
{
    if (totalPoints / quizCount >= 80)
    {
        System.out.println("Honor roll");
    }
}
System.out.println("Done");

Done

The outer condition quizCount != 0 is 0 != 0, which is false. Java skips the outer body, so totalPoints / quizCount on line 5 is never computed and nothing divides by zero. If quizCount were 3 instead, the outer condition would be true, the inner condition would compute 255 / 3, which is 85, and the program would print Honor roll and then Done. An outer condition used like this, to make sure the inner condition is safe to evaluate, is called a guard.

int totalPoints = 255;
int quizCount = 0;
if (totalPoints / quizCount >= 80)
{
    if (quizCount != 0)
    {
        System.out.println("Honor roll");
    }
}
System.out.println("Done");

Exception in thread "main" java.lang.ArithmeticException: / by zero

int speed = 38;
if (speed > 25)
{
    System.out.println("Over the limit");
    if (speed > 35)
    {
        System.out.println("Ticket");
    }
    System.out.println("Slow down");
}
System.out.println("Drive safely");

Over the limit
Ticket
Slow down
Drive safely

Drive safely

int pagesRead = 120;
int days = 0;
if (days > 0)
{
    if (pagesRead / days > 10)
    {
        System.out.println("Fast reader");
    }
}
System.out.println("Report finished");

An online store charges shipping in two different ways. Members get free shipping on orders of $25 or more and pay $3 otherwise. Everyone else gets free shipping at $50 or more and pays $6 otherwise. The first question is “Is this a member?”, and the second question depends on the answer. In 2.4.1 the inner if sat inside the “true” body. Here each answer needs its own follow-up question.

Recall from Topic 2.3 that an if-else statement has two bodies, and exactly one of them runs. Either body can hold a nested if. A nested if inside the else body is reached only when the outer condition is false. In general: an inner condition is evaluated only when Java actually enters the body that contains it.

boolean isMember = false;
int orderTotal = 40;
if (isMember)
{
    if (orderTotal >= 25)
    {
        System.out.println("Shipping: free");
    }
    else
    {
        System.out.println("Shipping: $3");
    }
}
else
{
    if (orderTotal >= 50)
    {
        System.out.println("Shipping: free");
    }
    else
    {
        System.out.println("Shipping: $6");
    }
}

isMember?
├── true:  orderTotal >= 25?
│          ├── true:  free
│          └── false: $3
└── false: orderTotal >= 50?
           ├── true:  free
           └── false: $6

Shipping: $6

Here are all four kinds of customer. In every row, exactly one of the four println statements runs:

Nesting does not have to be in both branches. A parking lot is free on weekends; on weekdays it costs $2 after 6 p.m. (hour 18 on a 24-hour clock) and $5 before. Only the weekday answer needs a second question, so only the else body holds a nested if:

boolean isWeekend = false;
int hour = 19;
if (isWeekend)
{
    System.out.println("Parking: free");
}
else
{
    if (hour >= 18)
    {
        System.out.println("Parking: $2");
    }
    else
    {
        System.out.println("Parking: $5");
    }
}

Parking: $2

isWeekend is false, so Java enters the else body and evaluates 19 >= 18, which is true. Had isWeekend been true, the program would have printed Parking: free and never looked at hour, whatever its value.

int age = 14;
boolean hasLicense = false;
if (age >= 16)
{
    if (hasLicense)
    {
        System.out.println("You may drive");
    }
    else
    {
        System.out.println("Get your license first");
    }
}
System.out.println("Done");

Done

int age = 14;
boolean hasLicense = false;
if (age >= 16)
{
    if (hasLicense)
    {
        System.out.println("You may drive");
    }
    else
    {
        System.out.println("Get your license first");
    }
}
else
{
    System.out.println("Too young to drive");
}
System.out.println("Done");

Too young to drive
Done

boolean isWeekend = false;
int age = 30;
if (isWeekend)
{
    if (age < 12)
    {
        System.out.println("$7");
    }
    else
    {
        System.out.println("$11");
    }
}
else
{
    if (age < 12)
    {
        System.out.println("$5");
    }
    else
    {
        System.out.println("$9");
    }
}

$9

Every example so far has used braces around every body, so it was easy to see which else went with which if. Java also lets you leave the braces off when a body is exactly one statement: the if (or else) then controls just that one statement. That is legal, and you will see such code on tests. But with nested ifs it raises a real question: when there are two ifs and one else, which if does the else belong to?

Java’s rule: without braces, an else belongs to the nearest if above it that does not already have an else. Indentation does not matter. Java ignores spaces and line breaks when it decides how statements fit together, so lining an else up under one if does not attach it to that if. An else that could seem to belong to either of two ifs is called a dangling else.

int score = 70;
if (score >= 50)
    if (score >= 90)
        System.out.println("Excellent");
else
    System.out.println("Failed");
System.out.println("Done");

if (score >= 50)
{
    if (score >= 90)
    {
        System.out.println("Excellent");
    }
    else
    {
        System.out.println("Failed");
    }
}
System.out.println("Done");

Failed
Done

Change the score to 45. Now 45 >= 50 is false, so Java skips the outer body, and the else is part of that body. The output is only Done; the failing score never printed Failed. And 95 prints Excellent and Done, as expected. The bug only shows for some inputs, which is why it is easy to miss.

To get the pairing you actually want, put braces around the outer body. The closing brace ends the outer body before the else, so the else can only belong to the outer if. This version calls a helper method report (an invented class method, like toMinutes in Topic 1.10) three times so you can see all three scores:

public class DanglingElseFixed
{
    public static void report(int score)
    {
        if (score >= 50)
        {
            if (score >= 90)
            {
                System.out.println("Excellent");
            }
        }
        else
        {
            System.out.println("Failed");
        }
        System.out.println("Done");
    }

    public static void main(String[] args)
    {
        report(70);
        report(45);
        report(95);
    }
}

Done
Failed
Done
Excellent
Done

report(70) prints only Done (passing, but not excellent), report(45) prints Failed and Done, and report(95) prints Excellent and Done.

int balance = -20;
if (balance >= 0)
    if (balance > 1000)
        System.out.println("Premium");
else
    System.out.println("Overdrawn");
System.out.println("Done");

A teacher wants to turn a score into a letter: A for 90 and up, B for 80 to 89, C for 70 to 79, D for 60 to 69. That is four possible outcomes, but an if-else only chooses between two. You could nest: if the score is not an A, ask whether it is a B; if not a B, ask about C; and so on. Each new question goes inside the previous else.

int score = 83;
if (score >= 90)
{
    System.out.println("Grade: A");
}
else
{
    if (score >= 80)
    {
        System.out.println("Grade: B");
    }
    else
    {
        if (score >= 70)
        {
            System.out.println("Grade: C");
        }
        else
        {
            if (score >= 60)
            {
                System.out.println("Grade: D");
            }
        }
    }
}

Grade: B

The staircase works, but it is hard to read. Look at each else body: it contains exactly one statement, the next if-else. Since a body with one statement does not need braces, Java lets you drop those braces and write the else and the next if on the same line. The result is the form programmers actually use:

int score = 83;
if (score >= 90)
{
    System.out.println("Grade: A");
}
else if (score >= 80)
{
    System.out.println("Grade: B");
}
else if (score >= 70)
{
    System.out.println("Grade: C");
}
else if (score >= 60)
{
    System.out.println("Grade: D");
}

Grade: B

This is the same code with fewer braces, so it behaves exactly like the staircase. A chain of conditions written if, else if, else if, … is called a multiway selection (also called an if-else-if statement). else if is not a new keyword: it is an else whose body is another if. That is why a multiway selection counts as a nested if statement.

How Java runs a multiway selection follows directly from the staircase:

1. Evaluate the conditions from top to bottom, one at a time.
2. At the first condition that is true, run its body, then skip the rest of the chain, including any conditions not yet checked.
3. If a condition is false, move on to the next else if.
4. If every condition is false, no body in the chain runs, and Java goes on to the statement after the chain.

Trace score equal to 83:

Notice that 83 >= 70 is also true, but that never matters, because Java stops at the first true condition. With score equal to 95, the very first condition is true, so the output is only Grade: A, even though all four conditions would be true for 95. And with score equal to 52, all four conditions are false, so this chain prints nothing at all.

int battery = 35;
if (battery >= 80)
{
    System.out.println("Full");
}
else if (battery >= 50)
{
    System.out.println("Good");
}
else if (battery >= 20)
{
    System.out.println("Low");
}
else if (battery >= 5)
{
    System.out.println("Very low");
}
System.out.println("Status shown");

Low
Status shown

Because Java stops at the first true condition, the order you write the conditions in is part of the program’s meaning. Rearranging the lines of a chain can change its output even though each condition is still correct on its own.

int score = 95;
if (score >= 60)
{
    System.out.println("Grade: D");
}
else if (score >= 70)
{
    System.out.println("Grade: C");
}
else if (score >= 80)
{
    System.out.println("Grade: B");
}
else if (score >= 90)
{
    System.out.println("Grade: A");
}

Grade: D

The fix is not “always put the biggest number first.” What matters is that each condition, given that all the ones above it were false, describes exactly the values that belong in that branch. With >=, that means checking the highest cutoff first. With <, it means checking the lowest cutoff first. Here is a correct chain that starts from the bottom and uses <:

int score = 95;
if (score < 60)
{
    System.out.println("Grade: F");
}
else if (score < 70)
{
    System.out.println("Grade: D");
}
else if (score < 80)
{
    System.out.println("Grade: C");
}
else if (score < 90)
{
    System.out.println("Grade: B");
}
else
{
    System.out.println("Grade: A");
}

Grade: A

Each else if is reached only when everything above it was false. So score < 70 is checked only when score < 60 was false, which means it catches exactly 60 to 69. A score of 95 fails all four < tests and reaches the final else (more on that in 2.4.6), which prints Grade: A.

int score = 95;
if (score >= 90)
{
    System.out.println("Grade: A");
}
if (score >= 80)
{
    System.out.println("Grade: B");
}
if (score >= 70)
{
    System.out.println("Grade: C");
}
if (score >= 60)
{
    System.out.println("Grade: D");
}

Grade: A
Grade: B
Grade: C
Grade: D

int weight = 3;
if (weight < 20)
{
    System.out.println("Large box");
}
else if (weight < 10)
{
    System.out.println("Medium box");
}
else if (weight < 5)
{
    System.out.println("Small box");
}

int weight = 3;
if (weight < 5)
{
    System.out.println("Small box");
}
else if (weight < 10)
{
    System.out.println("Medium box");
}
else if (weight < 20)
{
    System.out.println("Large box");
}

int temperature = 72;
if (temperature > 60)
{
    System.out.println("Warm");
}
if (temperature > 40)
{
    System.out.println("Mild");
}
if (temperature > 20)
{
    System.out.println("Cool");
}

int temperature = 72;
if (temperature > 60)
{
    System.out.println("Warm");
}
else if (temperature > 40)
{
    System.out.println("Mild");
}
else if (temperature > 20)
{
    System.out.println("Cool");
}

Warm
Mild
Cool

Warm

Recall the score of 52 from 2.4.4. All four conditions (52 >= 90, 52 >= 80, 52 >= 70, 52 >= 60) are false, so the letter-grade chain runs no body and prints nothing. A student who scored 52 gets no grade at all. The chain needs a way to say “and if none of those were true, do this.”

That is what a plain else at the end of the chain does. A trailing else is an else with no condition, placed after the last else if. Its body runs exactly when every condition in the chain was false. Think of it as the “none of the above” choice on a form.

int score = 52;
if (score >= 90)
{
    System.out.println("Grade: A");
}
else if (score >= 80)
{
    System.out.println("Grade: B");
}
else if (score >= 70)
{
    System.out.println("Grade: C");
}
else if (score >= 60)
{
    System.out.println("Grade: D");
}
else
{
    System.out.println("Grade: F");
}

Grade: F

Now a chain where the trailing else does real work in the middle of the range. A city bus is free for children under 5, costs $1 for ages 5 to 17 and for ages 65 and up, and costs $2 for everyone else:

int age = 40;
if (age < 5)
{
    System.out.println("Fare: free");
}
else if (age < 18)
{
    System.out.println("Fare: $1");
}
else if (age >= 65)
{
    System.out.println("Fare: $1");
}
else
{
    System.out.println("Fare: $2");
}

Fare: $2

For age equal to 40: 40 < 5 is false, 40 < 18 is false, 40 >= 65 is false, so the trailing else runs. “Everyone else” here is ages 18 to 64, a group the code never has to describe with a condition; the else catches whatever is left. Some other ages: 3 prints Fare: free, 12 prints Fare: $1, 70 prints Fare: $1, and 18 prints Fare: $2.

A trailing else is optional. Leave it out when doing nothing is the right result. This weather program should warn only about strong wind:

int windSpeed = 10;
if (windSpeed >= 74)
{
    System.out.println("Hurricane warning");
}
else if (windSpeed >= 39)
{
    System.out.println("Storm warning");
}
else if (windSpeed >= 25)
{
    System.out.println("Wind advisory");
}
System.out.println("Forecast complete");

Forecast complete

With windSpeed equal to 10, all three conditions are false and there is no trailing else, so no warning prints, which is exactly right for a calm day. The statement after the chain runs either way.

public class ElseInMiddle
{
    public static void main(String[] args)
    {
        int age = 40;
        if (age < 5)
        {
            System.out.println("Fare: free");
        }
        else
        {
            System.out.println("Fare: $2");
        }
        else if (age >= 65)
        {
            System.out.println("Fare: $1");
        }
    }
}

ElseInMiddle.java:14: error: 'else' without 'if'

int correct = 3;
if (correct >= 9)
{
    System.out.println("Expert");
}
else if (correct >= 6)
{
    System.out.println("Skilled");
}
else if (correct >= 4)
{
    System.out.println("Learning");
}
System.out.println("Quiz over");

Quiz over

public class ElseFirstBug
{
    public static void main(String[] args)
    {
        int minutes = 25;
        if (minutes >= 60)
        {
            System.out.println("Long workout");
        }
        else
        {
            System.out.println("Short workout");
        }
        else if (minutes >= 30)
        {
            System.out.println("Medium workout");
        }
    }
}

public class ElseFirstFixed
{
    public static void main(String[] args)
    {
        int minutes = 25;
        if (minutes >= 60)
        {
            System.out.println("Long workout");
        }
        else if (minutes >= 30)
        {
            System.out.println("Medium workout");
        }
        else
        {
            System.out.println("Short workout");
        }
    }
}

A movie theater charges $6 for every matinee ticket, whatever the age. Evening tickets cost $8 for children under 12, $9 for ages 65 and up, and $12 for everyone else. The program reads an age and a show type, here from a string so the output is predictable (keyboard input works the same way, as in Topic 1.4):

import java.util.Scanner;

public class TicketPrice
{
    public static void main(String[] args)
    {
        Scanner input = new Scanner("70 evening");
        int age = input.nextInt();
        String show = input.next();
        int price;
        if (show.equals("matinee"))
        {
            price = 6;
        }
        else
        {
            if (age < 12)
            {
                price = 8;
            }
            else if (age >= 65)
            {
                price = 9;
            }
            else
            {
                price = 12;
            }
        }
        System.out.println("Age " + age + ", " + show + " show");
        System.out.println("Ticket: $" + price);
    }
}

The structure is an outer if-else that asks about the show, with a multiway selection nested inside the else body. Trace it with the input 70 evening:

Age 70, evening show
Ticket: $9

Three ideas from this chapter made that work:

• Nesting in the else body (2.4.2). The age checks matter only for evening shows, so they sit inside the else. With the input 70 matinee, line 11 is true, price becomes 6, and none of the age conditions is evaluated.
• First true condition wins (2.4.4, 2.4.5). 70 >= 65 stopped the chain. Ages 12 to 64 fail both conditions and fall through.
• The trailing else (2.4.6). It catches everyone the two conditions did not, so 30 evening costs $12 and 8 evening costs $8. Because one body runs in every case, price always gets a value before line 31 prints it.

• An if statement can go inside the body of another if or else. This lets a program ask a follow-up question that depends on the answer to the first one, such as checking both ends of a range.
• An inner condition is evaluated only when Java enters the body that holds it: for an inner if in the if body, only when the outer condition is true. An outer condition can therefore guard an inner one that would otherwise crash.
• Without braces, an else belongs to the nearest earlier if that does not already have one, regardless of indentation. Braces on every body make the pairing clear.
• In a multiway selection (if, else if, …), Java runs the body of the first true condition and skips the rest, so at most one body runs. Because of that, the order of the conditions changes the result, and separate if statements behave differently from a chain.
• A trailing else runs when no condition in the chain is true, so exactly one body runs. Without it, a chain can run nothing.

int points = 42;
boolean isVip = true;
if (isVip)
{
    if (points >= 50)
    {
        System.out.println("Gold");
    }
    else if (points >= 30)
    {
        System.out.println("Silver");
    }
    else
    {
        System.out.println("Bronze");
    }
}
else
{
    System.out.println("Standard");
}
System.out.println("Thanks");

Silver
Thanks

Standard
Thanks

String code = "AB";
if (code.length() >= 3)
{
    if (code.substring(2, 3).equals("X"))
    {
        System.out.println("Express code");
    }
    else
    {
        System.out.println("Regular code");
    }
}
else
{
    System.out.println("Too short");
}

boolean isMember = true;
int points = 40;
if (isMember)
    if (points >= 100)
        System.out.println("Reward earned");
else
    System.out.println("Join today");

if (isMember)
{
    if (points >= 100)
    {
        System.out.println("Reward earned");
    }
}
else
{
    System.out.println("Join today");
}

int temperature = 85;
if (temperature > 80)
{
    System.out.println("Hot");
}
else if (temperature > 60)
{
    System.out.println("Warm");
}
if (temperature > 40)
{
    System.out.println("Mild");
}
else
{
    System.out.println("Cold");
}

• I can trace an if inside another if and say which conditions Java evaluates. Reread
• I can explain how an outer condition guards an inner one that would otherwise crash. Reread
• I can trace an if-else with a nested if in the if body, the else body, or both. Reread
• I can pair each else with the right if in code without braces, ignoring the indentation. Reread
• I can trace a multiway selection and explain why at most one body runs. Reread
• I can tell whether the conditions in a chain are in the right order, and how a chain differs from separate ifs. Reread
• I can say what a trailing else does and when a chain should have one. Reread