IN THIS CHAPTER

Dealing with many alternatives

Jumping out from the middle of a statement

Handling alternative assignments

Imagine playing Let’s Make a Deal with ten different doors. “Choose door number 1, door number 2, door number 3, door number 4 … Wait! Let’s break for a commercial. When we come back, I’ll say the names of the other six doors.”

What Monty Hall (the show’s host) needs is Java’s switch statement.

Meet the switch Statement

The code in Listing 9-2 (refer to Chapter 9) simulates a fortune-telling toy — an electronic oracle. Ask the program a question, and the program randomly generates a yes or no answer. But, as toys go, the code in Listing 9-2 isn’t much fun. The code has only two possible answers. There’s no variety. Even the earliest talking dolls could say about ten different sentences.

Suppose that you want to enhance the code of Listing 9-2. The call to myRandom.nextInt(10) + 1 generates numbers from 1 to 10. So maybe you can display a different sentence for each of the ten numbers. A big pile of if statements should do the trick:

if (randomNumber == 1) {
System.out.println("Yes. Isn’t it obvious?");
}
if (randomNumber == 2) {
System.out.println("No, and don’t ask again.");
}
if (randomNumber == 3) {
System.out.print("Yessir, yessir!");
System.out.println(" Three bags full.");
}
if (randomNumber == 4)
.
.
.
if (randomNumber < 1 || randomNumber > 10) {
System.out.print("Sorry, the electronic oracle");
System.out.println(" is closed for repairs.");
}

But that approach seems wasteful. Why not create a statement that checks the value of randomNumber just once and then takes an action based on the value that it finds? Fortunately, just such a statement exists: the switch statement. Listing 11-1 has an example of a switch statement.

LISTING 11-1 An Answer for Every Occasion

import java.util.Scanner;
import java.util.Random;
import static java.lang.System.out;

class TheOldSwitcheroo {

public static void main(String args[]) {
Scanner keyboard = new Scanner(System.in);
Random myRandom = new Random();
int randomNumber;

out.print("Type your question, my child: ");
keyboard.nextLine();

randomNumber = myRandom.nextInt(10) + 1;

switch (randomNumber) {
case 1:
out.println("Yes. Isn’t it obvious?");
break;

case 2:
out.println("No, and don’t ask again.");
break;

case 3:
out.print("Yessir, yessir!");
out.println(" Three bags full.");
break;

case 4:
out.println("What part of ’no’ don’t you understand?");
break;

case 5:
out.println("No chance, Lance.");
break;

case 6:
out.println("Sure, whatever.");
break;

case 7:
out.println("Yes, but only if you’re nice to me.");
break;

case 8:
out.println("Yes (as if I care).");
break;

case 9:
out.println("No, not until Cromwell seizes Dover.");
break;

case 10:
out.println("No, not until Nell squeezes Rover.");
break;

default:
out.print("You think you have problems?");
out.print(" My random number generator is broken!");
break;
}

out.println("Goodbye");

keyboard.close();
}
}

The cases in a switch statement

Figure 11-1 shows three runs of the program in Listing 11-1. Here’s what happens during one of these runs:

• The user types a heavy question, and the variable randomNumber gets a value. In the second run of Figure 11-1, this value is 2.
• Execution of the code in Listing 11-1 reaches the top of the switch statement, so the computer starts checking this statement’s case clauses. The value 2 doesn’t match the topmost case clause (the case 1 clause), so the computer moves on to the next case clause.
• The value in the next case clause (the number 2) matches the value of the randomNumber variable, so the computer executes the statements in this case 2 clause. These two statements are

  out.println("No, and don’t ask again.");
break;

  The first of the two statements displays No, and don’t ask again on the screen. The second statement is called a break statement. (What a surprise!) When the computer encounters a break statement, the computer jumps out of whatever switch statement it’s in. So, in Listing 11-1, the computer skips right past case 3, case 4, and so on. The computer jumps to the statement just after the end of the switch statement.

• The computer displays Goodbye because that’s what the statement after the switch statement tells the computer to do.

The overall idea behind the program in Listing 11-1 is illustrated in Figure 11-2.

To break or not to break

At one time or another, every Java programmer forgets to use break statements. At first, the resulting output is confusing, but then the programmer remembers fall-through. The term fall-through describes what happens when you end a case without a break statement. What happens is that execution of the code falls right through to the next case in line. Execution keeps falling through until you eventually reach a break statement or the end of the entire switch statement.

If you don’t believe me, just look at Listing 11-2. This listing’s code has a switch statement gone bad.

LISTING 11-2 Please, Gimme a Break!

/*
* This isn’t good code. The programmer forgot some
* of the break statements.
*/
import java.util.Scanner;
import java.util.Random;
import static java.lang.System.out;

class BadBreaks {

public static void main(String args[]) {
Scanner keyboard = new Scanner(System.in);
Random myRandom = new Random();
int randomNumber;

out.print("Type your question, my child: ");
keyboard.nextLine();

randomNumber = myRandom.nextInt(10) + 1;

switch (randomNumber) {
case 1:
out.println("Yes. Isn’t it obvious?");

case 2:
out.println("No, and don’t ask again.");

case 3:
out.print("Yessir, yessir!");
out.println(" Three bags full.");

case 4:
out.println("What part of ’no’ don’t you understand?");
break;

case 5:
out.println("No chance, Lance.");

case 6:
out.println("Sure, whatever.");

case 7:
out.println("Yes, but only if you’re nice to me.");

case 8:
out.println("Yes (as if I care).");

case 9:
out.println("No, not until Cromwell seizes Dover.");

case 10:
out.println("No, not until Nell squeezes Rover.");

default:
out.print("You think you have problems?");
out.println(" My random number generator is broken!");
}

out.println("Goodbye");

keyboard.close();
}
}

I’ve put two runs of this code in Figure 11-3. In the first run, the randomNumber is 7. The program executes cases 7 through 10, and the default. In the second run, the randomNumber is 3. The program executes cases 3 and 4. Then, because case 4 has a break statement, the program jumps out of the switch and displays Goodbye.

The switch statement in Listing 11-2 is missing some break statements. Even without these break statements, the code compiles with no errors. But when you run the code in Listing 11-2, you don’t get the results that you want.

Using Fall-Through to Your Advantage

Often, when you’re using a switch statement, you don’t want fall-through, so you pepper break statements throughout the switch. But, sometimes, fall-through is just the thing you need.

Take the number of days in a month. Is there a simple rule for this? Months containing the letter r have 31 days? Months in which i comes before e except after c have 30 days?

You can fiddle with if conditions all you want. But to handle all the possibilities, I prefer a switch statement. Listing 11-3 demonstrates the idea.

LISTING 11-3 Finding the Number of Days in a Month

import java.util.Scanner;

class DaysInEachMonth {

public static void main(String args[]) {

Scanner keyboard = new Scanner(System.in);
int month, numberOfDays = 0;
boolean isLeapYear;
System.out.print("Which month? ");
month = keyboard.nextInt();

switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
numberOfDays = 31;
break;

case 4:
case 6:
case 9:
case 11:
numberOfDays = 30;
break;

case 2:
System.out.print("Leap year (true/false)? ");
isLeapYear = keyboard.nextBoolean();
if (isLeapYear) {
numberOfDays = 29;
} else {
numberOfDays = 28;
}
}

System.out.print(numberOfDays);
System.out.println(" days");

keyboard.close();
}
}

Figure 11-4 shows several runs of the program in Listing 11-3. For month number 6, the computer jumps to case 6. There are no statements inside the case 6 clause, so that part of the program’s run is pretty boring.

But with no break in the case 6 clause, the computer marches right along to case 9. Once again, the computer finds no statements and no break, so the computer ventures to the next case, which is case 11. At that point, the computer hits pay dirt. The computer assigns 30 to numberOfDays and breaks out of the entire switch statement. (See Figure 11-5.)

February is the best month of all. For one thing, the February case in Listing 11-3 contains a call to the Scanner class’s nextBoolean method. The method expects me to type either true or false. The code uses whatever word I type to assign a value to a boolean variable. (In Listing 11-3, I assign true or false to the isLeapYear variable.)

February also contains its own if statement. In Chapter 10, I nest if statements within other if statements. But in February, I nest an if statement within a switch statement. That’s cool.

Here’s where you get practice using switch statements.

Using a Conditional Operator

Java has a neat feature that I can’t resist writing about. Using this feature, you can think about alternatives in a natural way.

And what do I mean by “a natural way”? If I think out loud as I imitate the if statement near the end of Listing 11-3, I come up with this:

//The thinking in Listing 11-3:
What should I do next?
If this is a leap year,
I’ll make the numberOfDays be 29;
Otherwise,
I’ll make the numberOfDays be 28.

I’m wandering into an if statement without a clue about what I’m doing next. That seems silly. It’s February, and everybody knows what you do in February. You ask how many days the month has.

In my opinion, the code in Listing 11-3 doesn’t reflect the most natural way to think about February. Here’s a more natural way:

//A more natural way to think about the problem:
The value of numberOfDays is…
Wait! Is this a leap year?
If yes, 29
If no, 28

In this second, more natural way of thinking, I know from the start that I’m picking a number of days. So by the time I reach a fork in the road (Is this a leap year?), the only remaining task is to choose between 29 and 28.

I can make the choice with finesse:

case 2:
System.out.print("Leap year (true/false)? ");
isLeapYear = keyboard.nextBoolean();
numberOfDays = isLeapYear ? 29 : 28;

The ? : combination is called a conditional operator. In Figure 11-6, I show you how my natural thinking about February can morph into the conditional operator’s format.

Taken as a whole, isLeapYear ? 29 : 28 is an expression with a value. And what value does this expression have? Well, the value of isLeapYear ? 29 : 28 is either 29 or 28. It depends on whether isLeapYear is or isn’t true. That’s how the conditional operator works:

• If the stuff before the question mark is true, the whole expression’s value is whatever comes between the question mark and the colon.
• If the stuff before the question mark is false, the whole expression’s value is whatever comes after the colon.

Figure 11-7 gives you a goofy way to visualize these ideas.

The conditional operator’s overall effect is as though the computer is executing

numberOfDays = 29;

or

numberOfDays = 28;

One way or another, numberOfDays gets a value, and the code solves the problem with style.

Get some practice using Java’s conditional operator.