Wat zijn records en sealed classes?

Question

Accepted Answer

**Records** (Java 16+) zijn beknopte, onveranderbare data carriers die automatisch boilerplate genereren, en **sealed classes** (Java 17+) beperken welke klassen een type kunnen uitbreiden/implementeren. Beide zijn moderne functies die Java expressiever maken en beter modelleren mogelijk stellen.

## Records — onveranderbare data, geen 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
```

Een record genereert automatisch de constructor, accessors, `equals()`, `hashCode()` en `toString()` op basis van zijn components. De velden zijn **final** (onveranderbaar) — records zijn ontworpen voor transparante, onveranderbare data carriers (DTOs, value objects, coördinaten).

## Records kunnen validatie en methoden hebben

```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 — gecontroleerde overerving

```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
```

Een `sealed` type somt expliciet zijn toegestane subtypes op — je controleert de volledige set implementaties, die de compiler afdwingt. Dit modelleert een **gesloten hiërarchie** (een vaste, bekende set varianten).

## Sealed + records + pattern matching = krachtig modelleren

```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
};
```

Omdat de subtypes van een sealed type bekend en eindig zijn, kan de compiler verifiëren dat een `switch` **exhaustief** is — ontbrekende gevallen opvangen. Gecombineerd met records en pattern matching brengt dit algebraïsche-data-type stijl modelleren naar Java.

## Waarom het belangrijk is

Records en sealed classes zijn belangrijke moderne Java-functies die expressiviteit en veiligheid verbeteren. **Records** elimineren de vervelende, foutgevoelige boilerplate van dataklassen (en garanderen correct, consistent `equals`/`hashCode` — oplossing voor die veel voorkomende valkuil) terwijl ze onveranderaarheid afdwingen — wat DTOs, value objects en data modeling veel schoner maakt. **Sealed classes** maken gesloten, gecontroleerde type-hiërarchieën mogelijk die de compiler begrijpt, wat — gecombineerd met records en pattern-matching `switch` — exhaustief, type-veilig hanteren van een vaste set varianten mogelijk maakt (algebraïsche data types).

Tezamen maken ze Java bondiger, onveranderbaar-standaard, en geschikt voor veiliger domein modellering.

Ze kennen weerspiegelt vlotheid met huidige Java en maakt schonere, meer robuuste ontwerpen mogelijk die ouder Java veel meer code voor nodig had.