2.2 Switch Statements and Switch Expressions

2.2 Switch Statements and Switch Expressions

The switch construct in Java provides multi-way branching based on the value of a selector expression. Since switch expressions were standardized in Java 14 (JEP 361), the language supports two label forms (colon case X: and arrow case X ->) and two uses of switch (as a statement that performs actions, or as an expression that produces a value with yield where needed). Java SE 17 LTS includes both. The 1Z0-829 exam tests deep knowledge of permitted selector types, compile-time constant requirements for case labels, fall-through rules, variable scoping, and exhaustiveness checks.

---

Permitted and Disallowed Selector Types

Java restricts the data types that may serve as the selector expression in a switch construct.

The null Selector Trap

If the selector expression evaluates to null at runtime—whether it is a boxed wrapper (such as Integer) or a String reference—Java immediately throws a NullPointerException upon entering the switch construct:

String input = null;

// Throws NullPointerException before checking any case or default!
switch (input) { 
    case "admin":
        System.out.println("Administrator");
        break;
    default:
        System.out.println("Guest");
}

The switch does not fall into the default branch when the selector is null. A runtime exception is thrown immediately.

---

Classic Switch Statements: Constant Expressions & Fall-Through

In classic switch statements, each case label must be a compile-time constant expression whose type is assignment-compatible with the switch selector:

1. Literals: e.g., case 1:, case "READY":.
2. Compile-Time Constant Variables: A variable declared final and initialized at the point of declaration with a constant expression (e.g., final int BASE = 10;).
3. Enum Constants: When switching on an enum type, the case label must specify the unqualified name of the enum constant (e.g., case NORTH:, not case Direction.NORTH:).

final int MAX = 100;
final int UNASSIGNED;
UNASSIGNED = 50; // Blank final: NOT a compile-time constant!
int dynamicValue = 20;

int test = 10;
switch (test) {
    case MAX:             // Legal: compile-time constant
        break;
    // case UNASSIGNED:   // COMPILE ERROR: constant expression required
    //     break;
    // case dynamicValue: // COMPILE ERROR: constant expression required
    //     break;
}

Furthermore, the value of a case label must fit within the range of the selector's primitive type. If switching on a byte (range -128 to 127), a case label of case 130: causes a compilation error: incompatible types: possible lossy conversion from int to byte.

Fall-Through Mechanics

Classic switch branches delimited with a colon (:) exhibit fall-through. If a matching case does not terminate with a break, return, throw, or yield, execution flows sequentially into the statements of subsequent cases regardless of whether those case labels match the selector:

int day = 2;
switch (day) {
    case 1:
        System.out.print("Mon ");
    case 2:
        System.out.print("Tue ");
    case 3:
        System.out.print("Wed ");
        break;
    default:
        System.out.print("Other ");
}
// Outputs: "Tue Wed "

If day is 2, execution jumps directly to case 2:. It prints "Tue ", falls through to case 3:, prints "Wed ", and then encounters break, which terminates the switch.

---

Variable Scoping Across Switch Cases

A classic switch block forms a single scope for local variables between the opening { and closing }. A variable declared inside one case remains in scope for all subsequent case and default blocks:

int selector = 1;
switch (selector) {
    case 1:
        int value = 42;
        System.out.println(value);
        break;
    case 2:
        // COMPILE ERROR: variable value is already defined in scope!
        int value = 99; 
        System.out.println(value);
        break;
    default:
        // value is still in scope here, but might NOT be initialized!
        // System.out.println(value); // COMPILE ERROR if used before initialization
}

To isolate variable declarations between cases, each branch must be enclosed in its own block using curly braces:

switch (selector) {
    case 1 -> { int value = 42; System.out.println(value); }
    case 2 -> { int value = 99; System.out.println(value); } // Legal in isolated blocks
}

---

Modern Switch Expressions (Java 14 / Java 17 LTS)

Java SE 17 provides modern switch expressions using the arrow (->) syntax. Switch expressions resolve many long-standing design traps of classic switches:

1. No Fall-Through: Exactly the code on the right-hand side of the matching arrow executes, so no break is needed. (A break is still legal inside an arrow block of a switch statement, but a switch expression cannot be exited with break.)
2. Multiple Comma-Separated Labels: Multiple matching values can share a single branch separated by commas (case 1, 2, 3 ->).
3. Value Production: A switch expression can return a value directly to a variable assignment or method call.

int month = 4;
int days = switch (month) {
    case 1, 3, 5, 7, 8, 10, 12 -> 31;
    case 4, 6, 9, 11 -> 30;
    case 2 -> 28;
    default -> 0;
};

---

The yield Keyword

When a branch in a switch expression requires multiple statements, the logic is enclosed in a block { ... }. To return a value from this block, Java uses the contextual keyword yield:

int code = 3;
String description = switch (code) {
    case 1 -> "Low Priority";
    case 2, 3 -> {
        String prefix = "Urgent: Level ";
        yield prefix + code; // Returns value from block
    }
    default -> "Standard";
};

Critical Rules Governing yield

• yield takes an argument and passes it as the result of the enclosing switch expression.
• return exits the entire enclosing method, whereas yield only exits the switch expression.
• You cannot use yield inside a classic switch statement that does not return a value.
• You cannot mix arrow (->) syntax and colon (:) syntax within the same switch construct. A switch must use exclusively arrows or exclusively colons.

// COMPILE ERROR: cannot mix ':' and '->' in the same switch
int invalid = switch (code) {
    case 1 -> 10;
    case 2: yield 20; 
    default -> 0;
};

---

Exhaustive Matching Requirements

When a switch is used as an expression (evaluating to a value), the compiler strictly requires exhaustive coverage of all possible input values:

1. Primitives and Strings: Because int, char, String, etc., have effectively boundless or large value domains, a default branch is mandatory. Omitting default results in a compile-time error: the switch expression does not cover all possible input values.
2. Enum Types: If the switch selector is an enum, a default case is optional if and only if every enum constant defined in the enumeration is explicitly handled by a case label:

enum Status { PENDING, ACTIVE, REJECTED }

Status current = Status.ACTIVE;

// Legal without 'default' because all 3 constants are covered:
int statusCode = switch (current) {
    case PENDING -> 1;
    case ACTIVE -> 2;
    case REJECTED -> 3;
};

If a new enum constant (e.g., CANCELLED) is subsequently added to the enum definition, the switch expression will fail compilation until the new constant is handled or a default branch is provided.

When a switch is used as a statement (performing actions without producing a value), exhaustiveness is not required.

---

Comparison: Classic Switch vs. Switch Expression