Fortgeschrittene switch-Ausdrücke

1. Was ist neu bei switch

Falls Sie vor Java 14 programmiert haben, sah switch ungefähr so aus:

switch (day) 
{
    case MONDAY:
        System.out.println("Wochenanfang!");
        break;
    case FRIDAY:
        System.out.println("Freitag, hurra!");
        break;
    default:
        System.out.println("Ein gewöhnlicher Tag.");
        break;
}

Klingt erstmal harmlos, aber:

• Man darf break nicht vergessen (sonst kommt es zum „Fall-through“ in den nächsten case).
• Viel sich wiederholender Code.
• Wenn man einen Wert zurückgeben möchte, muss man vorher eine Variable deklarieren und ihr in jedem case einen Wert zuweisen.

Java 14+ sagt: Es reicht! Zeit, switch bequemer und moderner zu machen.

Wesentliche Neuerungen:

• Switch ist nun ein Ausdruck, nicht nur eine Anweisung – er kann jetzt einen Wert zurückgeben.
• Neue Pfeil-Syntax -> statt Doppelpunkten und break.
• Mehrere case durch Komma – für identische Logik.
• Der Compiler prüft, dass alle Fälle abgedeckt sind (insbesondere bei enum).
• Kein Risiko des „Fall-through“ – das ist jetzt nur noch explizit möglich.

2. Syntax von switch-Ausdrücken

switch (znachenie)
{
   case A, B -> rezultat1;
   case C -> {
      // mehrere Aktionen
      yield rezultat2;
   }
   default -> rezultatPoUmolchaniyu;
}

Grundbeispiel

Kommen wir gleich zur Sache. So kann man jetzt einen Wert aus switch zurückgeben:

DayOfWeek day = DayOfWeek.MONDAY;

String message = switch (day) 
{
    case MONDAY, FRIDAY, SUNDAY -> "Kurze Woche oder frei!";
    case TUESDAY                -> "Dienstag – ein anstrengender Tag.";
    case WEDNESDAY, THURSDAY    -> "Mitte der Woche!";
    case SATURDAY               -> "Hurra, Samstag!";
    // default ist Pflicht, wenn nicht alle Fälle abgedeckt sind
    default                     -> "Irgendein seltsamer Tag...";
};

System.out.println(message);

Was passiert hier:

• switch (day) – ein Ausdruck, der einen Wert zurückgibt.
• Nach dem Pfeil -> steht das Ergebnis für diesen case.
• Mehrere case lassen sich per Komma zusammenfassen.
• Kein einziges break – Java weiß selbst, wo der Zweig endet.
• Das Ergebnis kann direkt der Variablen message zugewiesen werden.

Beispiel mit Zahlen

int code = 404;
String result = switch (code) 
{
    case 200 -> "OK";
    case 400, 404 -> "Clientfehler";
    case 500 -> "Serverfehler";
    default -> "Unbekannter Code";
};
System.out.println(result);

Beispiel mit Strings

String command = "start";
String status = switch (command) 
{
    case "start" -> "Start!";
    case "stop" -> "Stopp!";
    case "pause" -> "Pause...";
    default -> "Unbekannter Befehl";
};
System.out.println(status);

Einen Block mit yield verwenden

Manchmal möchte man für einen case mehrere Schritte ausführen (z. B. etwas Komplexes berechnen oder Logging machen). Dafür kann man einen Block { ... } und das Schlüsselwort yield verwenden:

int n = 7;
String parity = switch (n % 2) 
{
    case 0 -> "Gerade";
    case 1 -> 
    {
        System.out.println("Ungerade Zahl erkannt: " + n);
        yield "Ungerade";
    }
    default -> "Etwas Seltsames";
};
System.out.println(parity);

Wichtig: Im Block muss es ein yield geben, das den Wert für diesen case zurückgibt.

3. Vorteile der neuen Syntax

Kein Bedarf an break

Im klassischen switch ist ein vergessenes break eine Quelle von Schmerzen und mysteriösen Bugs. In der neuen Syntax ist break gar nicht nötig: Jeder Zweig endet automatisch.

Der Compiler prüft die Abdeckung aller Fälle

Wenn Sie ein enum verwenden und nicht alle Werte behandeln, lässt der Compiler das Projekt ohne default nicht kompilieren. Dadurch wird der Code zuverlässiger.

Kein „Fall-through“

Im klassischen switch fällt die Ausführung ohne break in den nächsten case hinein. In der neuen Syntax ist das unmöglich (es sei denn, Sie verwenden einen Block mit Anweisungen und schreiben explizit break – hier ist es jedoch nicht nötig).

Kompakterer und besser lesbarer Code

Vergleichen Sie selbst:

Vorher:

String result;
switch (status) {
    case "OK":
        result = "Alles gut";
        break;
    case "ERROR":
        result = "Fehler";
        break;
    default:
        result = "Unbekannt";
        break;
}

Nachher:

String result = switch (status) {
    case "OK" -> "Alles gut";
    case "ERROR" -> "Fehler";
    default -> "Unbekannt";
};

Mehrere case – eine Logik

case MONDAY, FRIDAY, SUNDAY -> "Freier oder kurzer Tag!";

4. Vergleich mit klassischem switch

5. Kompatibilität mit enum und Strings

Beispiel mit enum

Nehmen wir an, wir haben eine Aufzählung:

enum DayOfWeek 
{
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

Wir verwenden es im neuen switch:

DayOfWeek today = DayOfWeek.WEDNESDAY;

String mood = switch (today) 
{
    case MONDAY -> "Schwer aufzustehen...";
    case FRIDAY -> "Bald ist Wochenende!";
    case SATURDAY, SUNDAY -> "Hurra, Erholung!";
    default -> "Arbeitstag.";
};
System.out.println(mood);

Beispiel mit String

String season = "summer";
String activity = switch (season) 
{
    case "winter" -> "Schlittschuh laufen";
    case "summer" -> "Im See schwimmen";
    case "autumn" -> "Pilze sammeln";
    case "spring" -> "Vogelgesang hören";
    default -> "Unbekannte Jahreszeit";
};
System.out.println(activity);

6. Alten switch in den neuen Stil umschreiben

Vorher:

int day = 3;
String dayName;
switch (day) 
{
    case 1:
        dayName = "Montag";
        break;
    case 2:
        dayName = "Dienstag";
        break;
    case 3:
        dayName = "Mittwoch";
        break;
    default:
        dayName = "Unbekannter Tag";
        break;
}
System.out.println(dayName);

Nachher:

int day = 3;
String dayName = switch (day) 
{
    case 1 -> "Montag";
    case 2 -> "Dienstag";
    case 3 -> "Mittwoch";
    default -> "Unbekannter Tag";
};
System.out.println(dayName);

Noch ein Beispiel: mehrere case – eine Logik

int score = 5;
String grade = switch (score) 
{
    case 5, 6, 7 -> "Gut";
    case 8, 9, 10 -> "Ausgezeichnet";
    default -> "Man muss sich anstrengen";
};
System.out.println(grade);

7. Typische Fehler und Besonderheiten

Fehler Nr. 1: Kein default, wenn nicht alle Fälle abgedeckt sind. Wenn Sie einen switch-Ausdruck mit einem Typ verwenden, der Werte außerhalb der aufgezählten case haben kann (z. B. mit int oder String), verlangt der Compiler ein default. Für enum ist default ebenfalls erforderlich, wenn Sie nicht alle Werte abdecken.

Fehler Nr. 2: yield im Block vergessen. Wenn Sie für einen case geschweifte Klammern verwenden (es sollen mehrere Schritte ausgeführt werden), vergessen Sie yield nicht – ohne das meldet der Compiler den Fehler: "Missing yield statement".

Fehler Nr. 3: nicht übereinstimmende Typen. Alle Zweige eines switch-Ausdrucks müssen Werte desselben Typs zurückgeben; andernfalls lässt der Compiler den Code nicht durch.

Fehler Nr. 4: doppelte Werte für case. Derselben case zweimal anzugeben ist nicht erlaubt – der Compiler meldet sofort einen Fehler.

1

Umfrage/Quiz

Konstanten, enum und switch, Level 10, Lektion 5

Nicht verfügbar

Konstanten, enum und switch

Konstanten, enum und switch

Öffnen