Vad är records och sealed classes?

Question

Accepted Answer

**Records** (Java 16+) är koncisa, oföränderliga databärare som auto-genererar standardkod, och **sealed classes** (Java 17+) begränsar vilka klasser som kan utöka/implementera en typ. Båda är moderna funktioner som gör Java mer uttryckfullt och möjliggör bättre modellering.

## Records — oföränderlig data, noll standardkod

```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 auto-genererar konstruktorn, accessorer, `equals()`, `hashCode()` och `toString()` från dess komponenter. Fälten är **final** (oföränderliga) — records är utformade för transparenta, oföränderliga databärare (DTOs, värdeobjekt, koordinater).

## Records kan ha validering och 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 — kontrollerad 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`-typ listar explicit dess tillåtna undertyper — du kontrollerar den fullständiga uppsättningen av implementeringar, vilket kompilatorn tvingar fram. Detta modellerar en **sluten hierarki** (en fast, känd uppsättning varianter).

## Sealed + records + pattern matching = kraftfull 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
};
```

Eftersom en sealed-typs undertyper är kända och ändliga kan kompilatorn verifiera att en `switch` är **uttömmande** — fånga saknade fall. Kombinerat med records och pattern matching ger detta algebraisk-datatyp-stilmodellering till Java.

## Varför det spelar roll

Records och sealed classes är betydelsefulla moderna Java-funktioner som förbättrar uttrycksförmåga och säkerhet. **Records** eliminerar den tedious, felbenägen standardkod för dataklasser (och garanterar korrekt, konsistent `equals`/`hashCode` — löser det vanliga problemet) samtidigt som oföränderlighet tillämpas — vilket gör DTOs, värdeobjekt och datamodellering mycket renare. **Sealed classes** möjliggör slutna, kontrollerade typhierarkier som kompilatorn förstår, vilket — kombinerat med records och pattern-matching `switch` — tillåter uttömmande, typ-säker hantering av en fast uppsättning varianter (algebraiska datatyper).

Tillsammans gör de Java mer koncist, oföränderligt-som-standard och kapabelt till säkrare domänmodellering.

Att känna till dem återspeglar flytande kunskap om nuvarande Java och möjliggör renare, mer robusta design som äldre Java krävde mycket mer kod för att uppnå.