Switch Expressions and Arrow Labels

New words in this topic, in plain English. Come back here whenever one feels fuzzy.

Switch expression

A switch that produces a value you can assign or return, like int x = switch (...) { ... };.

Arrow label

A case X -> label. Only the code to its right runs; it never falls through.

yield

A statement inside a switch-expression block that says 'this is the switch's value'. It's a contextual keyword, so it's only special inside a switch expression.

Exhaustive

Covering every possible input. The compiler refuses a switch expression that might find no matching case.

Pattern

A shape to test a value against, like 'is an Integer'. If it matches, the value is also given a name you can use.

Guard

An extra when condition on a pattern case, like case Integer i when i > 0.

Sealed type

A class or interface that lists every class allowed to extend it, so the compiler knows all the possibilities (Java 17, Phase 5).

1. 1

   Break exhaustiveness on purpose

   In 'Exhaustive enum switch', add JUPITER to the enum. Compile and read the error. Then add case JUPITER -> "giant"; and run again.

2. 2

   Turn a statement into an expression

   Take the first practice answer from Topic 2.3 (days in a month) and rewrite daysIn as return switch (month) { ... }; with arrow labels. Count how many lines disappear.

3. 3

   Reorder pattern cases

   In 'Pattern matching for switch' (needs Java 21), move case Integer i -> above case Integer i when i > 100 ->. Compile. The error this case label is dominated by a preceding case label tells you the guarded case could never run.

Errors are the best teachers. Make each change, read the error, guess what went wrong, then reveal the answer.

public class Main {
    public static void main(String[] args) {
        int d = 9;
        String n = switch (d) {
            case 1 -> "Mon";
            case 2 -> "Tue";
        };
        System.out.println(n);
    }
}

public class Main {
    public static void main(String[] args) {
        int d = 3;
        String n = switch (d) {
            case 1 -> "Mon";
            default -> {
                String t = "Day " + d;
            }
        };
        System.out.println(n);
    }
}

1. 1

   An arrow label case 1 -> ... runs only the code on its right: one expression, one block in braces, or a throw. There is no fall-through and no break needed. Several values share one arrow with commas: case SAT, SUN -> "weekend". Arrow labels work in switch statements too, not only expressions.

2. 2

   A switch expression produces a value: String name = switch (day) { case 1 -> "Mon"; ... };. Note the semicolon after the closing brace: the whole thing is part of an assignment statement.

3. 3

   When an arm needs several statements, use a block and finish it with yield value;. yield means 'this is the value of the switch'. return can't be used for this (it would leave the whole method), and break out of a switch expression is a compile error.

4. 4

   A switch expression must be exhaustive: every possible selector value must be handled. For int or String that means a default. For an enum, listing every constant is enough, with no default. If someone later adds a constant, the code stops compiling instead of silently doing nothing, which is the biggest safety win of this feature.

5. 5

   Colon labels still work inside a switch expression (case 1: yield 10;) and still fall through, but you can't mix : and -> labels in one switch (different case kinds used in the switch).

6. 6

   Java 21 (JEP 441) adds pattern matching for switch: any reference type as a selector, type patterns (case Integer i ->), guards (case Integer i when i > 100 ->), case null, and exhaustiveness checks over sealed hierarchies (Phase 5). You'll use these heavily with records later in the course.

• ↔

  Switch expressions need Java 14+; older codebases (Java 8 and 11 are still common) can only use the classic statement.

• ↔

  Leaving out default on an enum switch gives compile-time safety when constants are added, but a library that adds constants can then break callers that compiled against the old version (they get MatchException at run time).

• ↔

  Pattern switches replace long instanceof chains neatly, but overusing them on open class hierarchies scatters behaviour; for types you own and extend often, polymorphism (Phase 5) may fit better.

• Done when you can write a switch expression with arrow labels, a block arm and yield.

• Done when you can explain why a switch expression must be exhaustive and fix the error when it isn't.

• Done when you choose to omit default on enum switch expressions and can say why.

• Done when you can read a Java 21 pattern switch with guards and case null.

• Done when you can convert any classic switch statement to the arrow form without changing its behaviour.