Java Switch Expressions (JEP 361): Pfeil, yield, kein break

Switch Expressions wurden in Java 14 im Rahmen von Project Amber veröffentlicht.

Bei Switch Expressions handelt es sich um zwei Erweiterungen, die unabhängig voneinander, aber auch kombiniert, eingesetzt werden können:

1. Pfeilnotation ohne break und Fall-Throughs
2. Verwendung von switch als Ausdruck mit Rückgabewert

Schauen wir uns die Änderungen eine nach der anderen an (ich verwende dazu die Beispiele aus JEP 361, leicht abgewandelt).

Ausgangslage

Im folgenden Beispiel wird für einen Wochentag die Wortlänge ausgegeben. Für die letzten beiden Fälle habe ich den Code etwas komplizierter als nötig geschrieben – um im Folgenden zu demonstrieren, was mit Switch Expressions möglich ist.

switch (day) {
  case MONDAY:
  case FRIDAY:
  case SUNDAY:
    System.out.println(6);
    break;
  case TUESDAY:
    System.out.println(7);
    break;
  case THURSDAY:
  case SATURDAY:
    System.out.println((int) Math.pow(2, 3));
    break;
  case WEDNESDAY:
    int three = 1 + 2;
    System.out.println(three * three);
    break;
}

Diese Schreibweise ist zum einen unübersichtlich, zum anderen fehleranfällig aufgrund der sogenannten „Fall-Throughs“, also der Ausführungsfortsetzung beim Folgefall, wenn der vorherige nicht mit einem break-Statement abgeschlossen wurde.

Entsprechend werden solche Konstrukte auch von den gängigen Tools für statische Code-Analyse (SCA) wie Sonar, Checkstyle und PMD als Code Smells moniert:

Switch mit Pfeilnotation

Das folgende Beispiel zeigt, wie du ab Java 14 statt des Doppelpunkts einen Pfeil verwenden kannst. Es gelten dabei folgende Regeln:

• Vor dem Pfeil darfst du mehrere Fälle kommasepariert auflisten.
• Nach dem Pfeil darf dann entweder ein einzelnes Code-Statement folgen (Zeilen 2, 3 und 4) oder ein Code-Block in geschweiften Klammern (Zeilen 5 bis 8).
• Die break-Statements fallen in dieser Notation weg.
• Pfeil- und Doppelpunkt-Form lassen sich innerhalb eines switch nicht mischen; der Compiler meldet sonst „different case kinds used in the switch“.

Hier der Beispiel-Code für ein switch-Statement in Pfeilnotation:

switch (day) {
  case MONDAY, FRIDAY, SUNDAY -> System.out.println(6);
  case TUESDAY                -> System.out.println(7);
  case THURSDAY, SATURDAY     -> System.out.println((int) Math.pow(2, 3));
  case WEDNESDAY -> {
    int three = 1 + 2;
    System.out.println(three * three);
  }
}

Moderne IDEs wie IntelliJ erkennen das Verbesserungspotenzial und bieten eine automatische Konvertierung in das neue Format an:

Switch als Ausdruck mit Rückgabewert

Oft verwenden wir switch, um einer Variablen einen fallspezifischen Wert zuzuweisen. Im folgenden Beispiel geben wir die Länge des Wochentages nicht aus, sondern speichern sie in der Variablen numLetters.

Die letzten zwei Fälle sind wieder absichtlich umständlich geschrieben, um zu zeigen, was mit Switch Expressions möglich ist.

int numLetters;
switch (day) {
  case MONDAY:
  case FRIDAY:
  case SUNDAY:
    numLetters = 6;
    break;
  case TUESDAY:
    numLetters = 7;
    break;
  case THURSDAY:
  case SATURDAY:
    numLetters = (int) Math.pow(2, 3);
    break;
  case WEDNESDAY:
    int three = 1 + 2;
    numLetters = three * three;
    break;
  default:
    throw new IllegalStateException("Unknown day: " + day);
}

Damit wir die Variable im Anschluss verwenden können, müssen wir bei dieser herkömmlichen Schreibweise – obwohl wir jeden Wochentag abgedeckt haben – entweder die Variable vorab mit einem Standardwert belegen oder einen default-Fall angeben. Andernfalls würde der Compiler mit der Fehlermeldung „variable numLetters might not have been initialized“ abbrechen.

Ab Java 14 können wir dieses Statement in einen Ausdruck umwandeln. Dabei geben wir mit dem neuen Keyword yield jeweils einen Wert zurück. Das Ergebnis der Switch Expression weisen wir dann direkt der Variablen zu:

int numLetters = switch (day) {
  case MONDAY, FRIDAY, SUNDAY:
    yield 6;

  case TUESDAY:
    yield 7;

  case THURSDAY, SATURDAY:
    yield (int) Math.pow(2, 3);

  case WEDNESDAY:
    int three = 1 + 2;
    yield three * three;

  default:
    throw new IllegalStateException("Unknown day: " + day);
};

Die kommaseparierten Labels aus dem vorigen Abschnitt funktionieren auch in der Doppelpunkt-Form.

yield ist ein sogenanntes „contextual keyword“ und damit nur im Kontext einer Switch Expression von Bedeutung. Falls du yield in deinem Quellcode als Variablenname verwendet haben solltest – keine Sorge, das kannst du weiterhin tun. Selbst so etwas wäre erlaubt:

int yield = 5; yield yield + yield;

Der default-Fall ist hier (im Gegensatz zur herkömmlichen Schreibweise) übrigens überflüssig – mehr dazu im Abschnitt Vollständigkeitsanalyse bei Enums.

Kombination von Pfeilnotation und Switch Expression

Deutlich eleganter wird die eben gezeigte Switch Expression, wenn wir sie in Pfeilnotation schreiben. Dabei können wir den Rückgabewert

• direkt hinter den Pfeil schreiben (Zeilen 2 und 3),
• als Ausdruck oder Methodenaufruf hinter den Pfeil schreiben (Zeile 4)
• oder aus einem Code-Block heraus mit yield zurückgeben (Zeile 7).

int numLetters = switch (day) {
  case MONDAY, FRIDAY, SUNDAY -> 6;                     // Zeile 2
  case TUESDAY                -> 7;                     // Zeile 3
  case THURSDAY, SATURDAY     -> (int) Math.pow(2, 3);  // Zeile 4
  case WEDNESDAY              -> {
    int three = 1 + 2;
    yield three * three;                                // Zeile 7
  }
  default -> throw new IllegalStateException("Unknown day: " + day);
};

Das komplette Refactoring vom herkömmlichen switch-Statement zur Switch Expression mit Pfeilnotation können wir unsere IDE erledigen lassen:

Vollständigkeitsanalyse bei Enums

Da es sich bei der Variablen day um ein Enum handelt, kann der Compiler erkennen, dass wir alle Fälle abgedeckt haben. Somit darf der default-Fall wegfallen:

int numLetters = switch (day) {
  case MONDAY, FRIDAY, SUNDAY -> 6;
  case TUESDAY                -> 7;
  case THURSDAY, SATURDAY     -> (int) Math.pow(2, 3);
  case WEDNESDAY              -> {
    int three = 1 + 2;
    yield three * three;
  }
};

Auch das erledigt unsere IDE für uns:

Die Schreibweise ohne default-Fall ist nicht nur kürzer, sondern hilft uns auch bei zukünftigen Erweiterungen des Enums. Sollten wir dieses – z. B. um einen NEWDAY – erweitern, wird der Compiler uns mitteilen, dass die Switch Expression nun unvollständig ist:

Switch Expressions können unseren Code also auch robuster machen.

Bei anderen Selektor-Typen wie String oder int kann der Compiler die Vollständigkeit nicht prüfen. Dort ist default in einer Switch Expression Pflicht – der Compiler meldet sonst „the switch expression does not cover all possible input values“.

Ein switch-Statement (also ein switch ohne Rückgabewert) darf hingegen unvollständig bleiben – es sei denn, es ist ein „modernes“ switch-Statement mit Pattern-Cases oder einem case null (siehe nächsten Abschnitt).

Switch seit Java 21

Mit Java 21 hat JEP 441 („Pattern Matching for switch“) das switch ein zweites Mal erweitert – auf derselben Grundlage, die du in diesem Artikel kennengelernt hast:

• Ein case kann statt einer Konstanten ein Type Pattern tragen und den Wert direkt an eine Variable binden: case String s -> …
• case null fängt einen null-Selektor ab, der bis dahin immer zu einer NullPointerException führte.
• Mit when schränkst du einen Fall zusätzlich ein (sogenannter Guard): case Integer i when i > 0 -> …
• Enum-Konstanten dürfen qualifiziert stehen: case Day.MONDAY statt case MONDAY.
• Die Vollständigkeitsanalyse gilt nicht mehr nur für Enums, sondern auch für Sealed Classes und Interfaces: Deckt der Switch alle erlaubten Subtypen ab, entfällt default genauso.

Selektoren der Typen long, float, double und boolean kommen mit Primitive Types in Patterns, instanceof und switch dazu – in Java 27 als fünfter Preview (JEP 532).

Fazit

Die Pfeilnotation und die Verwendung als Ausdruck mit Rückgabewert erlauben eine deutlich kompaktere, übersichtlichere und weniger fehleranfällige Schreibweise als bisher.

Ich empfehle, die Pfeilnotation als Standard zu verwenden – im Statement wie in der Expression. Die Doppelpunkt-Form brauchst du nur noch für Altcode, in dem ein Fall absichtlich in den nächsten durchfällt.

Switch Expressions wurden erstmals in Java 12 als Preview-Feature vorgestellt. Im zweiten Preview in Java 13 wurde das ursprünglich zur Rückgabe von Werten verwendete Keyword break durch yield ersetzt. Mit JDK Enhancement Proposal 361 wurden Switch Expressions in Java 14 ohne weitere Änderungen als finales Feature veröffentlicht.