Sealed mit Records
Geschlossene Hierarchien modellieren
Sealed mit Records ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 3 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.
Sealed und Records kombinieren
Versiegelte Interfaces und Records ergänzen sich perfekt. Das versiegelte Interface definiert eine geschlossene Menge von Fällen, und jeder Record ist ein konkreter, unveränderlicher Fall. Zusammen modellieren sie algebraische Datentypen.
Records sind implizit final
Ein Record ist automatisch final und erfüllt damit die Regel, dass erlaubte Untertypen final, sealed oder non-sealed sein müssen. Ein zusätzlicher Modifikator ist nicht erforderlich.
Eine geschlossene Formhierarchie
Modellieren Sie Formen als Records, die ein versiegeltes Interface implementieren und jeweils ihre eigenen Daten enthalten.
public class Main {
sealed interface Shape permits Circle, Rectangle {}
record Circle(double radius) implements Shape {}
record Rectangle(double width, double height) implements Shape {}
public static void main(String[] args) {
Shape s = new Rectangle(3, 4);
System.out.println(s);
}
}Verhalten hinzufügen
Das versiegelte Interface kann Methoden deklarieren, die jeder Record implementiert. So erhalten Sie Polymorphie über die geschlossene Menge.
public class Main {
sealed interface Shape permits Circle, Rectangle {
double area();
}
record Circle(double radius) implements Shape {
public double area() { return Math.PI * radius * radius; }
}
record Rectangle(double width, double height) implements Shape {
public double area() { return width * height; }
}
public static void main(String[] args) {
Shape s = new Circle(2);
System.out.printf("Area: %.2f%n", s.area());
}
}Kostenlose Gleichheit und toString
Records erzeugen equals, hashCode und toString automatisch. Zwei Records mit denselben Komponenten sind gleich, was ideal für die Modellierung von Werten ist.
public class Main {
sealed interface Shape permits Circle {}
record Circle(double radius) implements Shape {}
public static void main(String[] args) {
Circle a = new Circle(5);
Circle b = new Circle(5);
System.out.println(a.equals(b));
System.out.println(a);
}
}Ergebnisse modellieren
Ein häufig verwendetes Muster ist ein versiegelter Ergebnistyp mit einem Erfolgs-Record und einem Fehler-Record, der für erwartete Ergebnisse nullable Rückgabewerte oder Exceptions ersetzt.
public class Main {
sealed interface Result permits Ok, Err {}
record Ok(int value) implements Result {}
record Err(String message) implements Result {}
static Result parse(String s) {
try { return new Ok(Integer.parseInt(s)); }
catch (NumberFormatException e) { return new Err("bad number: " + s); }
}
public static void main(String[] args) {
System.out.println(parse("42"));
System.out.println(parse("oops"));
}
}Kompakte Konstruktoren zur Validierung
Records können ihre Eingaben in einem kompakten Konstruktor validieren, sodass jeder Fall bereits bei seiner Erstellung korrekt ist.
public class Main {
sealed interface Shape permits Circle {}
record Circle(double radius) implements Shape {
Circle {
if (radius < 0) throw new IllegalArgumentException("radius must be >= 0");
}
}
public static void main(String[] args) {
try { new Circle(-1); }
catch (IllegalArgumentException e) { System.out.println(e.getMessage()); }
}
}Rekursive Datenmodelle
Da ein Record auf das versiegelte Interface verweisen kann, können Sie rekursive Strukturen wie Ausdrucksbäume oder verkettete Listen erstellen.
public class Main {
sealed interface Expr permits Num, Add {}
record Num(int value) implements Expr {}
record Add(Expr left, Expr right) implements Expr {}
public static void main(String[] args) {
Expr e = new Add(new Num(1), new Add(new Num(2), new Num(3)));
System.out.println(e);
}
}Vorteile der Unveränderlichkeit
Records sind oberflächlich unveränderlich. Dadurch ist eine Hierarchie aus Records leicht nachvollziehbar, sicher gemeinsam zu verwenden und für nebenläufige Verarbeitung geeignet. Für die Records selbst sind keine defensiven Kopien erforderlich.
Mit switch kombinieren
Versiegelte Records kommen mit Pattern-Matching-switch besonders gut zur Geltung: Jeder Fall kann einen Record destrukturieren, und der Compiler überprüft, ob alle Fälle abgedeckt sind. Dies wird im Kurs zu Patterns näher behandelt.
Eine Berechnung über dem Modell
Sie können einen Interpreter als Methode schreiben, die den rekursiven Record-Baum durchläuft.
public class Main {
sealed interface Expr permits Num, Add {}
record Num(int value) implements Expr {}
record Add(Expr left, Expr right) implements Expr {}
static int eval(Expr e) {
if (e instanceof Num n) return n.value();
Add a = (Add) e;
return eval(a.left()) + eval(a.right());
}
public static void main(String[] args) {
Expr e = new Add(new Num(4), new Add(new Num(5), new Num(6)));
System.out.println(eval(e));
}
}Schnelltest
Testen Sie Ihr Verständnis von sealed Records.
Zusammenfassung
Sie haben gelernt, versiegelte Typen mit Records zu kombinieren.
- Records sind implizit final und können daher als erlaubte Untertypen eingesetzt werden.
- Das versiegelte Interface kann gemeinsame Methoden deklarieren.
- Records liefern automatisch Gleichheit, Hashing und toString.
- Zusammen modellieren sie geschlossene, unveränderliche und möglicherweise rekursive Daten.
Häufig gestellte Fragen
Ist die Lektion „Sealed mit Records“ kostenlos?
Ja — der vollständige Text von „Sealed mit Records“ 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 „Sealed mit Records“?
Geschlossene Hierarchien modellieren 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 3 von 4.
Wie lange dauert die Lektion „Sealed mit Records“?
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.