Hvad er records og sealed classes?

Question

Accepted Answer

**Records** (Java 16+) er konciσe, immutable datacontainere, der auto-genererer boilerplate-kode, og **sealed classes** (Java 17+) begrænser, hvilke klasser der kan udvide/implementere en type. Begge er moderne features, der gør Java mere udtryksfuldt og muliggør bedre modellering.

## Records — immutable data, nul 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
```

Et record auto-genererer konstruktoren, accessorer, `equals()`, `hashCode()` og `toString()` fra dets komponenter. Felterne er **final** (immutable) — records er designet til transparente, immutable datacontainere (DTOs, value objects, koordinater).

## Records kan have validering og metoder

```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 — kontrolleret arv

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

En `sealed` type ekspliciterer sine tilladte subtyper — du kontrollerer det komplette sæt af implementeringer, som compileren håndhæver. Dette modellerer et **lukket hierarki** (et fast, kendt sæt af varianter).

## Sealed + records + pattern matching = kraftfuld modellering

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

Fordi en sealed types subtyper er kendt og endelig, kan compileren verificere, at en `switch` er **exhaustive** — fejlfangning af manglende cases. Kombineret med records og pattern matching giver dette algebraic-data-type stil modellering til Java.

## Hvorfor det betyder noget

Records og sealed classes er betydningsfulde moderne Java features, der forbedrer udtryksfuldheden og sikkerheden. **Records** eliminerer kedelig, fejlprone boilerplate-kode af dataklasser (og garanterer korrekt, konsistent `equals`/`hashCode` — løser denne almindelige faldgrube) samtidig med at immutability håndhæves — hvilket gør DTOs, value objects og datamodellering langt renere. **Sealed classes** muliggør lukkede, kontrollerede typhierarker, som compileren forstår, hvilket — kombineret med records og pattern-matching `switch` — tillader exhaustive, type-sikker håndtering af et fast sæt varianter (algebraic data types).

Tilsammen gør de Java mere koncis, immutable-som-standard, og i stand til sikrere domain modellering.

At kende dem afspejler flydende beherskelse af nuværende Java og muliggør renere, mere robuste designs, som ældre Java krævede meget mere kode til at opnå.