Hvad er records og sealed classes?

Question

IT Interview Practice · 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å.

Records — immutable data, nul boilerplate

Records kan have validering og metoder

Sealed classes — kontrolleret arv

Sealed + records + pattern matching = kraftfuld modellering

Hvorfor det betyder noget

Relaterede spørgsmål