Java Academy · Lektion

Versiegelte Typen deklarieren

Festlegen, wer einen Typ erweitern darf

Versiegelte Typen deklarieren ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Was sind versiegelte Typen

Eine sealed-Klasse oder ein sealed-Interface beschränkt, welche anderen Typen sie erweitern oder implementieren dürfen. So können Sie eine geschlossene Menge von Möglichkeiten modellieren, über die der Compiler schlussfolgern kann.

Das Problem, das sie lösen

Eine normale public-Klasse kann von beliebigen Klassen an jedem Ort erweitert werden. Manchmal benötigen Sie genau drei Formen oder zwei Zahlungsarten, ohne unerwartete Varianten. Sealing macht diese Absicht ausdrücklich und stellt sie sicher.

Das Schlüsselwort sealed

Markieren Sie einen Typ mit sealed und listen Sie seine erlaubten Untertypen mit permits auf. Jeder erlaubte Untertyp muss seinen eigenen Vererbungsmodifikator deklarieren.

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

    public static void main(String[] args) {
        Shape s = new Circle(2.0);
        System.out.println(s);
    }
}

Modifikatoren für Untertypen

Jeder erlaubte Untertyp muss genau eines von Folgendem sein: final (keine weitere Vererbung), sealed (setzt die Einschränkung fort) oder non-sealed (öffnet die Vererbung wieder). Records sind implizit final.

Eine final-Unterklasse

Wenn Sie eine Unterklasse mit final markieren, schließen Sie die Hierarchie an diesem Zweig ab.

public class Main {
    sealed interface Animal permits Dog, Cat {}
    static final class Dog implements Animal {
        public String toString() { return "Dog"; }
    }
    static final class Cat implements Animal {
        public String toString() { return "Cat"; }
    }

    public static void main(String[] args) {
        Animal a = new Dog();
        System.out.println(a);
    }
}

Eine non-sealed-Unterklasse

Ein non-sealed-Untertyp öffnet die Vererbung absichtlich wieder, sodass unbekannte Klassen ihn erneut erweitern können. Verwenden Sie dies sparsam, wenn ein Zweig offen bleiben muss.

public class Main {
    sealed interface Plugin permits CorePlugin, ExternalPlugin {}
    static final class CorePlugin implements Plugin {}
    static non-sealed class ExternalPlugin implements Plugin {}
    static class ThirdParty extends ExternalPlugin {}

    public static void main(String[] args) {
        Plugin p = new ThirdParty();
        System.out.println(p.getClass().getSimpleName());
    }
}

Auch sealed-Klassen

Sealing ist nicht auf Interfaces beschränkt. Eine abstrakte sealed class funktioniert auf dieselbe Weise und kann gemeinsamen Zustand und gemeinsames Verhalten enthalten.

public class Main {
    sealed static abstract class Expr permits Num, Add {}
    static final class Num extends Expr {
        final int value;
        Num(int value) { this.value = value; }
    }
    static final class Add extends Expr {
        final Expr left, right;
        Add(Expr left, Expr right) { this.left = left; this.right = right; }
    }

    public static void main(String[] args) {
        Expr e = new Add(new Num(1), new Num(2));
        System.out.println(e.getClass().getSimpleName());
    }
}

Dasselbe Modul oder Paket

Erlaubte Untertypen müssen sich im selben Modul wie der versiegelte Typ befinden oder im selben Paket, wenn der Code nicht modular aufgebaut ist. Dadurch bleibt die geschlossene Menge zusammen und kann überprüft werden.

Überprüfung durch den Compiler

Wenn eine Klasse versucht, einen versiegelten Typ zu erweitern, ohne in permits aufgeführt zu sein, wird der Code nicht kompiliert. Die geschlossene Menge ist bereits zur Compile-Zeit garantiert.

Warum das wichtig ist

Weil der Compiler jeden Untertyp kennt, kann er überprüfen, ob ein switch über den versiegelten Typ alle Fälle behandelt. Das ist die Grundlage für eine vollständige Pattern-Matching-Prüfung, die in einem späteren Kurs behandelt wird.

Eine vollständige Hierarchie

Hier sehen Sie eine kleine geschlossene Hierarchie, die als Wertmodell verwendet wird.

public class Main {
    sealed interface Json permits JsonNull, JsonNumber, JsonString {}
    record JsonNull() implements Json {}
    record JsonNumber(double value) implements Json {}
    record JsonString(String value) implements Json {}

    public static void main(String[] args) {
        Json[] values = { new JsonNull(), new JsonNumber(3.5), new JsonString("hi") };
        for (Json j : values) {
            System.out.println(j);
        }
    }
}

Schnelltest

Testen Sie Ihr Verständnis von sealed-Deklarationen.

Zusammenfassung

Sie haben gelernt, versiegelte Typen zu deklarieren.

sealed beschränkt, wer einen Typ erweitern oder implementieren darf.
Die permits-Klausel listet die erlaubten Untertypen auf.
Jeder Untertyp muss final, sealed oder non-sealed sein.
Untertypen befinden sich im selben Modul oder Paket; der Compiler setzt diese Regel durch.

Häufig gestellte Fragen

Ist die Lektion „Versiegelte Typen deklarieren“ kostenlos?

Ja — der vollständige Text von „Versiegelte Typen deklarieren“ 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 „Versiegelte Typen deklarieren“?

Festlegen, wer einen Typ erweitern darf 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 1 von 4.

Wie lange dauert die Lektion „Versiegelte Typen deklarieren“?

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