Java Academy · Lektion

Fälle mit mehreren Labels

Gruppieren Sie mehrere Labels

Fälle mit mehreren Labels ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Bezeichnungen gruppieren

Oft sollen mehrere Werte dieselbe Aktion auslösen. Mit modernem switch können Sie mehrere Bezeichnungen in einem Fall durch Kommas getrennt angeben und so einen gemeinsamen Zweig verwenden.

Durch Kommas getrennte Bezeichnungen

Schreiben Sie die Werte vor -> nacheinander und durch Kommas getrennt. Wenn einer von ihnen übereinstimmt, wird der Zweig ausgeführt.

public class Main {
    public static void main(String[] args) {
        int day = 7;
        switch (day) {
            case 1, 2, 3, 4, 5 -> System.out.println("Weekday");
            case 6, 7 -> System.out.println("Weekend");
        }
    }
}

Vokale erkennen

Ein klassischer Anwendungsfall: Alle Vokale werden in einem Zweig zusammengefasst, statt fünf separate Fälle zu schreiben.

public class Main {
    public static void main(String[] args) {
        char c = 'o';
        switch (c) {
            case 'a', 'e', 'i', 'o', 'u' -> System.out.println("Vowel");
            default -> System.out.println("Consonant");
        }
    }
}

Mehrere Bezeichnungen in Ausdrücken

Fälle mit mehreren Bezeichnungen funktionieren auch in switch-Ausdrücken. Für jede der aufgeführten Bezeichnungen wird derselbe Wert zurückgegeben.

public class Main {
    public static void main(String[] args) {
        int month = 7;
        String season = switch (month) {
            case 12, 1, 2 -> "Winter";
            case 3, 4, 5 -> "Spring";
            case 6, 7, 8 -> "Summer";
            default -> "Autumn";
        };
        System.out.println(season);
    }
}

String-Bezeichnungen gruppieren

Auch String-Werte können gruppiert werden. Hier werden mehrere Schreibweisen eines Befehls auf eine gemeinsame Aktion abgebildet.

public class Main {
    public static void main(String[] args) {
        String cmd = "quit";
        switch (cmd) {
            case "quit", "exit", "q" -> System.out.println("Closing");
            case "help", "h" -> System.out.println("Showing help");
            default -> System.out.println("Unknown command");
        }
    }
}

Enum-Bezeichnungen gruppieren

Auch Enum-Konstanten können sich einen Zweig teilen, wodurch die Logik für Kategorien kompakt bleibt.

public class Main {
    enum Day { MON, TUE, WED, THU, FRI, SAT, SUN }
    public static void main(String[] args) {
        Day d = Day.SAT;
        String kind = switch (d) {
            case SAT, SUN -> "Rest";
            default -> "Work";
        };
        System.out.println(kind);
    }
}

Keine doppelten Bezeichnungen

Jede Bezeichnung darf im gesamten switch nur einmal vorkommen. Wenn derselbe Wert in zwei Zweigen aufgeführt wird, ist das ein Kompilierungsfehler, da der Compiler nicht entscheiden könnte, welcher Zweig ausgeführt werden soll.

public class Main {
    public static void main(String[] args) {
        int n = 2;
        switch (n) {
            case 1, 2 -> System.out.println("Low");
            case 3, 4 -> System.out.println("High");
            default -> System.out.println("Other");
        }
    }
}

Im Vergleich zum alten fall-through

Im alten Stil mit Doppelpunkten erforderte die Gruppierung leere Fälle mit fall-through, die untereinander vor einem gemeinsamen Block standen. Die Kommasyntax ist deutlich übersichtlicher und verhindert versehentliches fall-through.

public class Main {
    public static void main(String[] args) {
        int code = 3;
        switch (code) {
            case 1, 3, 5, 7, 9 -> System.out.println("Odd");
            case 0, 2, 4, 6, 8 -> System.out.println("Even");
        }
    }
}

Gruppieren mit Blöcken

Ein gruppierter Fall kann ebenfalls einen Blockkörper verwenden. Bei jeder übereinstimmenden Bezeichnung wird der gesamte Block ausgeführt.

public class Main {
    public static void main(String[] args) {
        char grade = 'B';
        switch (grade) {
            case 'A', 'B' -> {
                System.out.println("Pass");
                System.out.println("Well done");
            }
            default -> System.out.println("Try again");
        }
    }
}

Mit yield kombinieren

Gruppierte Bezeichnungen und yield lassen sich kombinieren, wenn ein gemeinsamer Zweig Berechnungen benötigt.

public class Main {
    public static void main(String[] args) {
        int n = 4;
        int points = switch (n) {
            case 1, 2, 3 -> 10;
            case 4, 5, 6 -> {
                int bonus = n * 2;
                yield 20 + bonus;
            }
            default -> 0;
        };
        System.out.println(points);
    }
}

Ein Gewinn für die Lesbarkeit

Fälle mit mehreren Bezeichnungen verkürzen lange Listen sich wiederholender Zweige zu einigen klaren Gruppen, sodass die Absicht sofort erkennbar ist.

public class Main {
    public static void main(String[] args) {
        int http = 204;
        String group = switch (http / 100) {
            case 1, 2, 3 -> "OK-ish";
            case 4, 5 -> "Error";
            default -> "Unknown";
        };
        System.out.println(group);
    }
}

Kurze Überprüfung

Wie sorgen Sie dafür, dass mehrere Werte denselben switch-Zweig ausführen?

Zusammenfassung

Sie haben Fälle mit mehreren Bezeichnungen kennengelernt:

Listen Sie Werte vor -> durch Kommas getrennt auf
Funktioniert für int, char, Strings und Enums
Kein versehentliches fall-through wie im alten Stil
Jede Bezeichnung darf nur einmal vorkommen
Bei Bedarf mit Blöcken und yield kombinieren

Häufig gestellte Fragen

Ist die Lektion „Fälle mit mehreren Labels“ kostenlos?

Ja — der vollständige Text von „Fälle mit mehreren Labels“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Fälle mit mehreren Labels“?

Gruppieren Sie mehrere Labels Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Fälle mit mehreren Labels“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Java Academy