Switch Statements

A switch is a way to choose between several possible outcomes based on one value. This article follows a traced run of a small program that chooses a value and stores it in a variable. As you read, keep two questions in mind: which case the switch chose, and what value ended up in the variable. Most of the rules in this article come from one observation: a switch expression is part of an assignment, so the value it computes is the value that gets stored.

A switch statement tests one expression and jumps to the case label that matches its value. A switch expression also chooses a case, but it computes and returns a single value, so it is used when the purpose of the switch is to produce a value for an assignment or another expression. Many switch statements exist for one purpose: to assign a value to a variable, where the value depends on which case matched. The expression form handles that pattern more directly.

Read the template from left to right. The variable on the left receives the result. The keyword switch is followed by the controlling expression in parentheses. Each case has a value, an arrow, and then an expression that gives the result for that case. The default case covers any value not matched by an earlier case. The closing brace is followed by the semicolon that ends the assignment.

In the anatomy above, the case values are the labels that the controlling expression is compared against. The result expressions are the values the switch produces when that case is chosen. The default entry is the fallback. The source explains that each case holds an expression rather than a statement, which is why the arrow form separates each case's value from the result it produces.

Sometimes a case needs more than one step before it can produce its value. In that situation, the expression in the case can be replaced by a block containing several statements. The block itself does not produce the switch's value. Instead, the value is specified by a yield statement, such as yield 42. The value after the word yield is returned as the value of the switch expression. Only the case that was chosen runs, so only its yield determines the result.

When a switch expression produces a surprising value, the useful question is which case was chosen and what that case produced. In the traced run, the divergence point is the case that was actually selected, not the variable that was assigned. The assignment only stores what the switch returned, so a wrong stored value usually traces back to a case expression or a yield value that was not the one you expected.

Switch expressions are not limited to assignment statements. Because they compute a value, you can use one anywhere another expression could be used, such as inside an output statement. The same tracing steps apply in that case: find the chosen entry, then find the value it produces.

A switch statement only accepts expressions of certain types. The value of the expression can be one of the primitive integer types int, short, or byte. It can be the primitive char type. It can be String. It can also be an enum type, which is a type whose values are named constants. The expression may not be double or float.

The positions a switch can jump to are marked with case labels. A case label takes the form case followed by a constant list. The constant list consists of one or more literals of the same type as the expression in the switch, separated by commas. The label is followed by an arrow, made of a hyphen and a greater-than character, and then a single statement. That statement can be a subroutine call statement, a throw statement, or a block statement containing several nested statements. A switch can also have at most one default entry in place of a case label, and all case constants must be different.

Java has two syntaxes for switch statements. The original syntax was modeled on the C programming language, and the source describes it as error-prone and somewhat awkward to read. It is still common in existing code, so you need to be able to read it. In this form, the code under one label keeps running until a break is reached. That is why an unexpected result can start at a case label and continue into the next one.

Read the flowchart as the trace of the program. Control jumps directly to the case 2 label because count is 2. The line word = two runs, but nothing stops execution there. The code under case 3 runs next, so word becomes three. The first break is reached after that, and then println prints three. The divergence point is the case 2 label, where control arrives. The missing break after word = two is what lets execution continue.

This article follows the new syntax first, and the traditional form is treated later. Both forms rest on the same idea: a value selects a jump point. Learning the case label rules carefully therefore helps with either form.