Java switch-Anweisung: Cases, Fall-Through und Pfeil-Syntax

Wofür switch da ist

Ein switch vergleicht einen Wert mit einer Liste fester Optionen und führt den passenden Zweig aus. Wenn du dich dabei ertappst, eine lange if/else if-Kette zu schreiben, die immer wieder dieselbe Variable gegen verschiedene Konstanten prüft, sagt ein switch dasselbe klarer.

Er führt nur Gleichheitsprüfungen gegen zur Kompilierzeit bekannte Konstanten durch – er kann keine Bereiche prüfen oder Bedingungen kombinieren. Dafür bleib bei if/else.

Die klassische switch-Anweisung

Die traditionelle Form verwendet case-Labels mit Doppelpunkten und ein break nach jedem Zweig:

public class Main {
    public static void main(String[] args) {
        int day = 3;

        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            default:
                System.out.println("Some other day");
        }
    }
}

Java wertet day aus, springt zum passenden case, führt seine Anweisungen aus, und das break verlässt den switch. Der default-Zweig läuft, wenn nichts anderes passt – stell ihn dir wie das else vor. Er ist optional, aber ihn einzubinden ist gute Praxis, damit unerwartete Werte nicht stillschweigend durchrutschen.

Die break-Falle: Fall-Through

Das ist der mit Abstand häufigste switch-Fehler. Wenn du ein break weglässt, stoppt die Ausführung nicht am Ende eines passenden Cases – sie fällt durch in den nächsten Case und läuft weiter, bis sie auf ein break oder die schließende Klammer trifft:

public class Main {
    public static void main(String[] args) {
        int level = 1;

        switch (level) {
            case 1:
                System.out.println("Level 1");
                // no break - falls through!
            case 2:
                System.out.println("Level 2");
            case 3:
                System.out.println("Level 3");
                break;
        }
    }
}

Du könntest nur Level 1 erwarten, aber dies gibt alle drei Zeilen aus. Da case 1 kein break hat, rutscht die Steuerung direkt in case 2 und case 3. Füge immer ein break hinzu, es sei denn, du willst den Fall-Through wirklich – und wenn du dich darauf verlässt, hinterlasse einen Kommentar, damit der nächste Leser weiß, dass es Absicht war.

Cases gruppieren

Der Fall-Through hat einen legitimen, sauberen Einsatzzweck: case-Labels zu stapeln, damit mehrere Werte sich einen Block teilen. Setze die Labels ohne Code dazwischen direkt hintereinander:

public class Main {
    public static void main(String[] args) {
        char grade = 'B';

        switch (grade) {
            case 'A':
            case 'B':
            case 'C':
                System.out.println("Pass");
                break;
            case 'D':
            case 'F':
                System.out.println("Fail");
                break;
            default:
                System.out.println("Unknown grade");
        }
    }
}

Hier führen 'A', 'B' und 'C' alle dieselbe "Pass"-Zeile aus. Das ist der vorgesehene Weg, um zu sagen „jeder dieser Werte macht dasselbe".

switch auf Strings

Du bist nicht auf Zahlen beschränkt. Seit Java 7 kannst du auf einen String switchen, was sich perfekt für Menüauswahlen oder Befehlsnamen eignet:

public class Main {
    public static void main(String[] args) {
        String command = "stop";

        switch (command) {
            case "start":
                System.out.println("Starting...");
                break;
            case "stop":
                System.out.println("Stopping...");
                break;
            default:
                System.out.println("Unknown command: " + command);
        }
    }
}

Der Vergleich ist von der Groß-/Kleinschreibung abhängig – "Stop" würde nicht mit "stop" übereinstimmen, also normalisiere zuerst (z. B. command.toLowerCase()), wenn die Schreibweise der Eingabe variiert. Noch ein Fallstrick: Wenn command null ist, wirft der switch eine NullPointerException, also sichere dich gegen null ab, bevor du dorthin gelangst.

Die moderne Pfeil-Syntax

Neueres Java (14+) fügt eine Pfeilform hinzu, case label -> ..., die die Fall-Through-Falle von Grund auf behebt. Jeder Pfeil-Case führt genau einen Zweig aus und fällt nie durch, also gibt es kein break, das man vergessen könnte:

public class Main {
    public static void main(String[] args) {
        int day = 6;

        switch (day) {
            case 1, 2, 3, 4, 5 -> System.out.println("Weekday");
            case 6, 7          -> System.out.println("Weekend");
            default            -> System.out.println("Invalid day");
        }
    }
}

Beachte, dass du Werte mit einem Komma gruppierst (case 6, 7), statt Labels zu stapeln, und es ist kein einziges break in Sicht. Für mehrere Anweisungen verwende einen Block: case 1 -> { ...; ... }. Bevorzuge diese Form in neuem Code – sie ist kürzer und beseitigt eine ganze Fehlerklasse.

switch als Ausdruck

Die Pfeilform kann auch einen Wert erzeugen. Ein switch-Ausdruck liefert ein Ergebnis, das du direkt einer Variablen zuweisen kannst – keine temporäre Variable, keine wiederholte Zuweisung in jedem Zweig:

public class Main {
    public static void main(String[] args) {
        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 -> throw new IllegalArgumentException("Bad month: " + month);
        };

        System.out.println("Days: " + days);
    }
}

Der gesamte switch (...) { ... } wertet sich zu einer Zahl aus, die in days gespeichert wird. Beachte das Semikolon nach der schließenden Klammer – es ist Teil der Zuweisungsanweisung. Ein switch-Ausdruck muss erschöpfend sein (jeden möglichen Wert abdecken), weshalb hier das default steht. Wenn ein Zweig mehrere Anweisungen braucht, bevor er einen Wert zurückgibt, verwende einen Block mit yield:

case 2 -> {
    boolean leap = (year % 4 == 0);
    yield leap ? 29 : 28;
}

yield ist die Art, wie ein Pfeil-Block seinen Wert zurückgibt – das Pendant in der Ausdruckswelt zu einem break, das ein Ergebnis trägt.

Als Nächstes: for-Schleifen

switch wählt einen Zweig aus vielen aus; manchmal musst du stattdessen einen Block viele Male wiederholen. Die for-Schleife führt Code eine kontrollierte Anzahl von Malen aus – indem sie durch einen Bereich zählt oder über jedes Element schreitet – und ist die nächste Seite.