Java Academy · Lektion

Patterns in switch

Versiegelte Typen und Patterns kombinieren

Patterns in switch 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.

Patterns in switch

switch hat sich vom Abgleich von Konstanten zum Abgleich von Patterns weiterentwickelt. Zusammen mit versiegelten Typen und Records kann ein switch nach Typen verzweigen, Daten destrukturieren und Vollständigkeit garantieren.

Typ-Patterns in switch

Jeder case-Zweig kann ein Typ-Pattern sein, das eine typisierte Variable für diesen Zweig bindet.

public class Main {
    static String kind(Object o) {
        return switch (o) {
            case Integer i -> "int " + i;
            case String s -> "string " + s;
            default -> "other";
        };
    }

    public static void main(String[] args) {
        System.out.println(kind(42));
        System.out.println(kind("hi"));
        System.out.println(kind(3.14));
    }
}

Versiegelte Typen benötigen kein default

Wenn der Selektor ein versiegelter Typ ist und Sie jeden zulässigen Subtyp abdecken, ist der switch auch ohne default vollständig.

public class Main {
    sealed interface Shape permits Circle, Square {}
    record Circle(double r) implements Shape {}
    record Square(double s) implements Shape {}

    static double area(Shape shape) {
        return switch (shape) {
            case Circle c -> Math.PI * c.r() * c.r();
            case Square sq -> sq.s() * sq.s();
        };
    }

    public static void main(String[] args) {
        System.out.printf("%.2f%n", area(new Square(3)));
    }
}

Record-Patterns in Cases

Cases können Records destrukturieren und ihre Komponenten direkt im Rumpf des Zweigs verfügbar machen.

public class Main {
    sealed interface Shape permits Circle, Rectangle {}
    record Circle(double r) implements Shape {}
    record Rectangle(double w, double h) implements Shape {}

    static double area(Shape shape) {
        return switch (shape) {
            case Circle(double r) -> Math.PI * r * r;
            case Rectangle(double w, double h) -> w * h;
        };
    }

    public static void main(String[] args) {
        System.out.printf("%.2f%n", area(new Rectangle(2, 5)));
    }
}

Guards mit when

Eine when-Klausel fügt einem case-Zweig einen booleschen Guard hinzu. Der case greift nur, wenn das Pattern passt und der Guard true ist.

public class Main {
    static String size(Object o) {
        return switch (o) {
            case Integer i when i < 0 -> "negative";
            case Integer i when i == 0 -> "zero";
            case Integer i -> "positive";
            default -> "not an int";
        };
    }

    public static void main(String[] args) {
        System.out.println(size(-5));
        System.out.println(size(0));
        System.out.println(size(7));
    }
}

Bei Guards ist die Reihenfolge wichtig

Cases mit Guard werden von oben nach unten geprüft. Ein spezifischerer case mit Guard muss vor einem allgemeineren case ohne Guard stehen, sonst würde der allgemeine case den spezifischeren bereits abfangen.

null behandeln

Fügen Sie case null hinzu, um einen null-Selektor zu behandeln; andernfalls löst der switch NullPointerException aus. Sie können ihn sogar als case null, default kombinieren.

public class Main {
    static String label(String s) {
        return switch (s) {
            case null -> "missing";
            case "yes" -> "affirmative";
            default -> "other: " + s;
        };
    }

    public static void main(String[] args) {
        System.out.println(label(null));
        System.out.println(label("yes"));
        System.out.println(label("maybe"));
    }
}

Verschachtelte Patterns in switch

Cases können Record-Patterns verschachteln, um tiefe Strukturen zu matchen und an inneren Werten an einer einzigen Stelle Guards anzuwenden.

public class Main {
    record Point(int x, int y) {}
    record Line(Point a, Point b) {}

    static String describe(Object o) {
        return switch (o) {
            case Line(Point(var x1, var y1), Point(var x2, var y2)) when x1 == x2 -> "vertical";
            case Line(Point a, Point b) -> "line";
            default -> "other";
        };
    }

    public static void main(String[] args) {
        System.out.println(describe(new Line(new Point(1, 0), new Point(1, 5))));
        System.out.println(describe(new Line(new Point(0, 0), new Point(2, 3))));
    }
}

Anweisungen und Ausdrücke

Pattern-Switch funktioniert sowohl als Ausdruck, der mit -> oder yield einen Wert liefert, als auch als Anweisung. Wenn der Selektor versiegelt ist, gelten die Regeln für die Vollständigkeit.

Visitor-Code ersetzen

Zusammen ersetzen versiegelte Typen und Pattern-Switch ausführliche Visitor-Patterns und instanceof-Kaskaden durch eine kompakte, vom Compiler geprüfte Verzweigung über ein abgeschlossenes Modell.

Ein vollständiger Interpreter

Ein Ausdrucksauswerter, der ein versiegeltes Modell und einen Pattern-Switch verwendet.

public class Main {
    sealed interface Expr permits Num, Add, Mul {}
    record Num(int value) implements Expr {}
    record Add(Expr left, Expr right) implements Expr {}
    record Mul(Expr left, Expr right) implements Expr {}

    static int eval(Expr e) {
        return switch (e) {
            case Num(int v) -> v;
            case Add(Expr l, Expr r) -> eval(l) + eval(r);
            case Mul(Expr l, Expr r) -> eval(l) * eval(r);
        };
    }

    public static void main(String[] args) {
        Expr e = new Add(new Num(2), new Mul(new Num(3), new Num(4)));
        System.out.println(eval(e));
    }
}

Kurzer Test

Testen Sie Ihr Verständnis von Patterns in switch.

Zusammenfassung

Sie haben Patterns in switch gelernt.

Cases können Typ-Patterns und Record-Patterns mit Destrukturierung sein.
Versiegelte Selektoren ermöglichen vollständige switch-Ausdrücke ohne default.
when-Guards verfeinern die Cases; die Reihenfolge ist wichtig.
case null behandelt null sicher.

Häufig gestellte Fragen

Ist die Lektion „Patterns in switch“ kostenlos?

Ja — der vollständige Text von „Patterns in switch“ 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 „Patterns in switch“?

Versiegelte Typen und Patterns kombinieren 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 „Patterns in switch“?

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