0Pricing
Java Academy · Lektion

Vollständiger switch für Sealed-Typen

Vollständigkeit zur Compile-Zeit

Vollständiger switch für Sealed-Typen 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.

Vollständiger switch

Wenn Sie über einen versiegelten Typ switchen, kennt der Compiler jeden erlaubten Untertyp. Wenn Ihr switch alle abdeckt, ist er vollständig, und Sie benötigen keinen default-Zweig.

Ein switch mit Typ-Pattern

Switch-Ausdrücke können mithilfe von Typ-Patterns auf den Laufzeittyp eines versiegelten Werts prüfen.

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

    static String describe(Shape s) {
        return switch (s) {
            case Circle c -> "circle r=" + c.radius();
            case Square sq -> "square s=" + sq.side();
        };
    }

    public static void main(String[] args) {
        System.out.println(describe(new Circle(2)));
        System.out.println(describe(new Square(3)));
    }
}

Kein default erforderlich

Da Circle und Square die einzigen erlaubten Untertypen sind, akzeptiert der Compiler den switch als vollständig. Ein default wäre überflüssig.

Vollständigkeit zur Compile-Zeit

Wenn Sie später einen neuen erlaubten Untertyp hinzufügen und vergessen, ihn zu behandeln, wird jeder vollständige switch nicht kompiliert. Dadurch wird eine ganze Klasse von Laufzeitfehlern in Compile-Fehler umgewandelt.

Ein Ergebnis berechnen

Vollständige switch-Ausdrücke eignen sich hervorragend dazu, einen Wert auf ein Ergebnis wie die Fläche zu reduzieren.

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

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

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

Switch-Anweisungen und -Ausdrücke

Die Vollständigkeitsprüfung gilt für switch-Ausdrücke (solche, die einen Wert liefern) sowie für switch-Anweisungen, die bei einem versiegelten Typ die Pfeilsyntax verwenden. Der Compiler setzt die vollständige Abdeckung durch.

null behandeln

Standardmäßig löst ein switch über eine Referenz NullPointerException aus, wenn der Wert null ist. Sie können ein case null-Label hinzufügen, um diesen Fall ausdrücklich zu behandeln.

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

    static String describe(Shape s) {
        return switch (s) {
            case null -> "no shape";
            case Circle c -> "circle";
            case Square sq -> "square";
        };
    }

    public static void main(String[] args) {
        System.out.println(describe(null));
        System.out.println(describe(new Circle(1)));
    }
}

Guards beeinträchtigen die Vollständigkeit nicht

Sie können when-Guards hinzufügen, um Fälle genauer einzugrenzen. Ein Fall mit Guard allein gilt jedoch nicht als abgedeckt. Damit der switch vollständig bleibt, benötigen Sie weiterhin für jeden Untertyp einen Fall ohne Guard.

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

    static String size(Shape s) {
        return switch (s) {
            case Circle c when c.radius() > 10 -> "big circle";
            case Circle c -> "small circle";
            case Square sq -> "square";
        };
    }

    public static void main(String[] args) {
        System.out.println(size(new Circle(20)));
        System.out.println(size(new Circle(2)));
    }
}

Über eine sealed-Klasse switchen

Dieselbe Vollständigkeitsprüfung funktioniert auch für versiegelte Klassen und nicht nur für Interfaces.

public class Main {
    sealed static abstract class Token permits Word, Number {}
    static final class Word extends Token { final String text; Word(String t){text=t;} }
    static final class Number extends Token { final int value; Number(int v){value=v;} }

    static String show(Token t) {
        return switch (t) {
            case Word w -> "word:" + w.text;
            case Number n -> "num:" + n.value;
        };
    }

    public static void main(String[] args) {
        System.out.println(show(new Word("hi")));
        System.out.println(show(new Number(7)));
    }
}

Warum das so leistungsfähig ist

Vollständiger switch und versiegelte Typen ergeben sicheren, weiterentwickelbaren Code. Die Menge der Fälle ist an einer Stelle dokumentiert, und der Compiler garantiert, dass beim Wachstum des Modells kein Fall vergessen wird.

Ein vollständiges Beispiel

Hier wird ein versiegelter Ergebnistyp mit vollständiger Abdeckung in eine Nachricht umgewandelt.

public class Main {
    sealed interface Result permits Ok, Err {}
    record Ok(int value) implements Result {}
    record Err(String message) implements Result {}

    static String render(Result r) {
        return switch (r) {
            case Ok ok -> "value = " + ok.value();
            case Err err -> "error: " + err.message();
        };
    }

    public static void main(String[] args) {
        System.out.println(render(new Ok(10)));
        System.out.println(render(new Err("bad input")));
    }
}

Schnelltest

Testen Sie Ihr Verständnis von vollständigem switch.

Zusammenfassung

Sie haben vollständigen switch mit versiegelten Typen kennengelernt.

  • Wenn alle erlaubten Untertypen abgedeckt sind, ist der switch vollständig, sodass kein default erforderlich ist.
  • Das Fehlen eines neuen Untertyps führt zu einem Compile-Fehler.
  • case null behandelt null-Werte ausdrücklich.
  • Guards grenzen Fälle genauer ein, ersetzen aber keinen Fall ohne Guard.

Häufig gestellte Fragen

Ist die Lektion „Vollständiger switch für Sealed-Typen“ kostenlos?

Ja — der vollständige Text von „Vollständiger switch für Sealed-Typen“ 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 „Vollständiger switch für Sealed-Typen“?

Vollständigkeit zur Compile-Zeit 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 „Vollständiger switch für Sealed-Typen“?

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

  1. Versiegelte Typen deklarieren
  2. permits-Klausel
  3. Sealed mit Records
  4. Vollständiger switch für Sealed-Typen
← Zurück zu Java Academy