Hva er records og sealed classes?

Question

Accepted Answer

**Records** (Java 16+) er konsise, immutable databærere som autogenererer boilerplate, og **sealed classes** (Java 17+) begrenser hvilke klasser som kan utvide/implementere en type. Begge er moderne funksjoner som gjør Java mer uttrykksfull og muliggjør bedre modellering.

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

En record autogenererer konstruktøren, accessor-metoder, `equals()`, `hashCode()` og `toString()` fra komponentene. Feltene er **final** (immutable) — records er designet for transparente, immutable databærere (DTOer, value objects, koordinater).

## Records kan ha 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 — kontrollert arving

```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 lister eksplisitt opp sine tillatte undertyper — du kontrollerer hele settet av implementasjoner, som kompilatoren håndhever. Dette modellerer en **lukket hierarki** (et fast, kjent sett av varianter).

## Sealed + records + pattern matching = kraftig 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 undertyper er kjente og endelige, kan kompilatoren verifisere at en `switch` er **uttømmende** — fanger manglende tilfeller. Kombinert med records og pattern matching, bringer dette algebraisk-datatype-stil modellering til Java.

## Hvorfor det betyr noe

Records og sealed classes er betydningsfulle moderne Java-funksjoner som forbedrer uttrykksfullhet og sikkerhet. **Records** eliminerer det kjedelige, feilutsatt boilerplate i datiklasser (og garanterer korrekte, konsistente `equals`/`hashCode` — løser det vanlige problemet) samtidig som immutability håndheves — gjør DTOer, value objects og datamodellering langt renere. **Sealed classes** muliggjør lukkede, kontrollerte typehierarkier som kompilatoren forstår, som — kombinert med records og pattern-matching `switch` — tillater uttømmende, typesikker håndtering av et fast sett av varianter (algebraiske datatyper).

Tilsammen gjør de Java mer konsise, immutable-by-default, og i stand til sikrere domenemodelering.

Å kjenne dem reflekterer flyt med dagens Java og muliggjør renere, mer robuste design som eldre Java krevde mye mer kode for å oppnå.