Was sind Records und sealed Classes?

Question

Accepted Answer

**Records** (Java 16+) sind prägnante, unveränderliche Datenträger, die Boilerplate-Code automatisch generieren, und **sealed classes** (Java 17+) beschränken, welche Klassen einen Typ erweitern/implementieren können. Beides sind moderne Features, die Java ausdrucksstarker machen und bessere Modellierung ermöglichen.

## Records — unveränderliche Daten, kein Boilerplate

```java
// ❌ a traditional data class needs ~40 lines of boilerplate
// (fields, constructor, getters, equals, hashCode, toString)

// ✅ a record generates ALL of that automatically
public record Point(int x, int y) {}

Point p = new Point(3, 4);
p.x();              // 3 — accessor (note: x(), not getX())
p.equals(new Point(3, 4));   // true — equals() generated
p;                  // Point[x=3, y=4] — toString() generated
p.hashCode();       // generated, consistent with equals
```

Ein Record generiert automatisch den Konstruktor, Accessoren, `equals()`, `hashCode()` und `toString()` aus seinen Komponenten. Die Felder sind **final** (unveränderlich) — Records sind für transparente, unveränderliche Datenträger (DTOs, Value Objects, Koordinaten) ausgelegt.

## Records können Validierung und Methoden haben

```java
public record Range(int min, int max) {
    public Range {                          // compact constructor — validate
        if (min > max) throw new IllegalArgumentException("min > max");
    }
    public int size() { return max - min; }  // can add methods
}
```

## Sealed Classes — kontrollierte Vererbung

```java
// restrict WHO can extend/implement — only the named classes
public sealed interface Shape permits Circle, Square, Triangle {}

public final class Circle implements Shape { double radius; }
public final class Square implements Shape { double side; }
public final class Triangle implements Shape { double base, height; }
// no other class can implement Shape
```

Ein `sealed`-Typ listet explizit seine zulässigen Subtypen auf — Sie kontrollieren die vollständige Menge der Implementierungen, die der Compiler durchsetzt. Dies modelliert eine **geschlossene Hierarchie** (ein fester, bekannter Satz von Varianten).

## Sealed + Records + Pattern Matching = mächtige Modellierung

```java
// the compiler KNOWS all the cases → exhaustive switch (no default needed)
double area = switch (shape) {
    case Circle c -> Math.PI * c.radius() * c.radius();
    case Square s -> s.side() * s.side();
    case Triangle t -> 0.5 * t.base() * t.height();
    // no default needed — sealed guarantees these are ALL the cases
};
```

Weil die Subtypen eines sealed-Typs bekannt und endlich sind, kann der Compiler überprüfen, dass ein `switch` **erschöpfend** ist — fehlende Fälle werden erfasst. Kombiniert mit Records und Pattern Matching bringt dies algebraische-Datentyp-ähnliche Modellierung zu Java.

## Warum es wichtig ist

Records und sealed Classes sind bedeutende moderne Java-Features, die Ausdrucksfähigkeit und Sicherheit verbessern. **Records** beseitigen den mühsamen, fehleranfälligen Boilerplate-Code von Datenklassen (und garantieren korrekte, konsistente `equals`/`hashCode` — wodurch dieses häufige Problem gelöst wird) und erzwingen Unveränderlichkeit — DTOs, Value Objects und Datenmodellierung werden viel sauberer. **Sealed Classes** ermöglichen geschlossene, kontrollierte Typenhierarchien, die der Compiler versteht, was — kombiniert mit Records und Pattern-Matching `switch` — erschöpfende, typsichere Behandlung einer festen Menge von Varianten (algebraische Datentypen) ermöglicht.

Zusammen machen sie Java prägnanter, unveränderlich-by-default und in der Lage für sicherere Domain-Modellierung, die älteres Java mit viel mehr Code erreichen musste.

Das Verständnis dieser Features spiegelt Geläufigkeit mit modernem Java wider und ermöglicht sauberere, robustere Designs, die älteres Java mit viel mehr Code erreichen musste.