2.2 Switch Statements and Switch Expressions

Switch Statements, Switch Expressions, and Yield

The switch construct in Java has evolved from a legacy C-style branching statement into a versatile, expression-oriented construct. The 1Z0-830 exam tests both classic switch statements and modern switch expressions, including selector data types, fall-through mechanics, constant expressions, the yield keyword, and compiler exhaustiveness checks.

---

1. Supported Switch Selector Data Types

The type of the switch selector expression determines which features and case labels are valid:

Classic Switch Selector Types (Java 1.0 - Java 20):

• Integral Primitives: byte, short, char, int.
• Wrapper Classes: Byte, Short, Character, Integer.
• Strings: java.lang.String (supported since Java 7).
• Enumerations: enum constants (supported since Java 5).

Unsupported Selector Types in Non-Pattern Switch:

• long, float, double, boolean (and their respective wrappers Long, Float, Double, Boolean). Attempting to switch over a long or double without pattern matching yields a compile-time error: incompatible types: possible lossy conversion from long to int.

Pattern Matching Switch Selector Types (Java 21):

• In Java 21, pattern matching allows any reference type (including Object, interfaces, and custom record classes) as the selector expression.

---

2. Classic switch Statements (: Colon Syntax)

A classic switch statement uses case labels ending with a colon (:).

Fall-Through Behavior

Execution enters at the first matching case label and continues sequentially through subsequent case blocks and default until encountering a break, return, throw, or the end of the switch block:

int day = 2;
switch (day) {
    case 1:
        System.out.print("Mon ");
    case 2:
        System.out.print("Tue "); // Matches day = 2
    case 3:
        System.out.print("Wed "); // Falls through!
        break;
    case 4:
        System.out.print("Thu ");
    default:
        System.out.print("Weekend ");
}
// Output: "Tue Wed "

Constant Expression Requirements for Case Labels

Every case value in a classic switch must be a compile-time constant expression assignable to the selector type:

• Literals (e.g., case 1:, case "ACTIVE":)
• final variables initialized with compile-time constant expressions (e.g., final int MAX = 10; case MAX:)
• Enum constants (written without the qualifying enum type name: case ACTIVE: rather than case Status.ACTIVE:)

final int x = 10;
int y = 20; // non-final
final int z;
z = 30; // blank final, NOT a compile-time constant!

int target = 10;
switch (target) {
    case x: // Valid: compile-time constant
        break;
//  case y: // COMPILE ERROR: constant expression required
//      break;
//  case z: // COMPILE ERROR: constant expression required
//      break;
}

Single Shared Lexical Scope

In colon-syntax switch statements, the entire switch block forms a single lexical scope. Local variables declared in one case are in scope for all subsequent cases, which can lead to variable declaration clashes:

int mode = 1;
switch (mode) {
    case 1:
        int count = 10; // Declared in switch scope
        System.out.println(count);
        break;
    case 2:
        // int count = 20; // COMPILE ERROR: Variable 'count' already defined in scope
        count = 20; // Legal: reassigning the variable declared in case 1!
        System.out.println(count);
        break;
}

To isolate local variables within a single case, the case body must be wrapped in explicit block braces: case 1: { int count = 10; break; }.

---

3. Modern switch Expressions (-> Arrow Syntax)

Introduced in Java 14 (JEP 361), switch expressions treat branching as a value-producing expression.

Arrow (->) Syntax Rules

1. No Fall-Through: Only the expression, block, or throw statement to the right of the arrow is executed. No break statements are needed or allowed to prevent fall-through.
2. Multiple Comma-Separated Labels: Multiple values can be combined into a single case label: case 1, 2, 3 -> "Q1";.
3. Right-Hand Side Forms:
   • Single expression: case 1 -> "One";
   • Block with yield: case 2 -> { String res = "Two"; yield res; }
   • Exception throw: case 3 -> throw new IllegalArgumentException();

String season = switch (month) {
    case 12, 1, 2  -> "Winter";
    case 3, 4, 5   -> "Spring";
    case 6, 7, 8   -> "Summer";
    case 9, 10, 11 -> "Autumn";
    default        -> "Invalid month";
}; // Semicolon required when used in assignment!

---

4. The yield Keyword and Scope Isolation

The yield Statement

yield is a contextual keyword (not a reserved identifier) introduced to return values from switch expression blocks:

int score = 85;
String grade = switch (score / 10) {
    case 10, 9 -> "A";
    case 8 -> {
        System.out.println("Good job!");
        yield "B"; // Returns "B" as the switch expression result
    }
    case 7 -> "C";
    default -> "F";
};

yield vs. return vs. break

• yield value;: Produces a value for a switch expression block. It cannot be used in a switch statement.
• return value;: Exits the enclosing method, NOT just the switch expression. Attempting to return a switch value with return inside a switch expression block will exit the method entirely!
• break;: Valid in classic colon switch statements to terminate execution. Using break value; is obsolete syntax from early preview versions and will not compile.

Lexical Isolation with Arrow Syntax

Unlike colon-syntax switch statements, each arrow branch with curly braces {} defines its own independent local variable scope:

int val = 1;
switch (val) {
    case 1 -> {
        int temp = 100;
        System.out.println(temp);
    }
    case 2 -> {
        int temp = 200; // Perfectly legal! Isolated scope.
        System.out.println(temp);
    }
    default -> {}
}

---

5. Switch Statement vs. Switch Expression Comparison

---

6. Compiler Exhaustiveness Requirements

When switch is used as an expression, the Java compiler requires that it handles all possible values of the selector type:

• For primitive types (int, char, etc.) and String, a default case is almost always mandatory because their domain of values is effectively infinite.
• For enum types, if all enum constants are covered, the compiler does not require a default clause. However, if any enum constant is missing and there is no default, compilation fails with the switch expression does not cover all possible input values.

enum Status { PENDING, APPROVED, REJECTED }

Status s = Status.PENDING;
// Compiles cleanly without default because all 3 enum values are handled:
String text = switch (s) {
    case PENDING  -> "Please wait";
    case APPROVED -> "Welcome";
    case REJECTED -> "Access denied";
};