Co jsou records a sealed classes?

Question

Accepted Answer

**Records** (Java 16+) jsou stručné, neměnné nosiče dat, které automaticky generují boilerplate, a **sealed classes** (Java 17+) omezují, které třídy mohou rozšiřovat/implementovat typ. Obě jsou moderní funkce, které činí Javu expresivnější a umožňují lepší modelování.

## Records — neměnná data, nula 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
```

Record automaticky generuje konstruktor, přístupové metody, `equals()`, `hashCode()` a `toString()` z jeho komponent. Pole jsou **final** (neměnná) — records jsou určeny jako transparentní, neměnné nosiče dat (DTOs, objekty hodnot, souřadnice).

## Records mohou mít validaci a metody

```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 — kontrolovaná dědičnost

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

Typ `sealed` explicitně vyjmenovává své povolené podtypy — kontrolujete úplnou sadu implementací, kterou kompilátor vynucuje. To modeluje **uzavřenou hierarchii** (pevně danou, známou sadu variant).

## Sealed + records + pattern matching = výkonné modelování

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

Protože podtypy sealed typu jsou známé a konečné, kompilátor může ověřit, že `switch` je **vyčerpávající** — zachycuje chybějící případy. V kombinaci s records a pattern matchingem to přináší modelování stylu algebraických datových typů do Javy.

## Proč na tom záleží

Records a sealed classes jsou významné moderní funkce Javy, které zlepšují expresivitu a bezpečnost. **Records** eliminují únavný, náchylný na chyby boilerplate datových tříd (a zaručují správné, konzistentní `equals`/`hashCode` — řeší tuto běžnou chybu) a zároveň vynucují neměnnost — což činí DTOs, objekty hodnot a modelování dat daleko čistšími. **Sealed classes** umožňují uzavřené, kontrolované hierarchie typů, kterým kompilátor rozumí, což — v kombinaci s records a pattern-matching `switch` — umožňuje vyčerpávající, typově bezpečné zpracování pevné sady variant (algebraické datové typy).

Dohromady činí Javu stručnější, neměnností-ve-výchozím-stavu a schopnou bezpečnějšího modelování domény.

Znalost těchto funkcí odráží plynulost s moderní Javou a umožňuje čistší, robustnější návrhy, kterých starší Java vyžadovala mnohem více kódu k dosažení.