Kas yra records ir sealed klasės?

Question

Accepted Answer

**Records** (Java 16+) yra glaustos, nekintamos duomenų nešiotuvės, kurios automatiškai generuoja standartinį kodą, o **sealed klasės** (Java 17+) riboja, kurios klasės gali jų plėsti arba jas implementuoti. Abu yra šiuolaikinės funkcijos, kurios Java padaro išraiškingesnę ir leidžia geriau modeliuoti.

## Records — nekintami duomenys, jokio standartinio kodo

```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 automatiškai generuoja konstruktorių, prieigos metodus, `equals()`, `hashCode()` ir `toString()` iš savo komponentų. Laukai yra **final** (nekintami) — records sukurti skaidriems, nekintimiems duomenų nešiotuvėms (DTO, vertės objektams, koordinatėms).

## Records gali turėti validaciją ir metodus

```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 klasės — kontroliuojamas paveldėjimas

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

`sealed` tipas aiškiai nurodo savo leistinus subtipus — jūs kontroliuojate visą implementacijų rinkinį, kurį kompilyatorius primušta. Tai modeliuoja **uždarą hierarchiją** (fiksuotą, žinomą variantų rinkinį).

## Sealed + records + pattern matching = galingas modeliavimas

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

Nes sealed tipo subtipai yra žinomi ir baigtiniai, kompilyatorius gali patikrinti, ar `switch` yra **išsamus** — pagavęs trūkstamus atvejus. Kartu su records ir pattern matching, tai Java atneša algebrinio duomenų tipo stiliaus modeliavimą.

## Kodėl tai svarbu

Records ir sealed klasės yra reikšmingos šiuolaikinės Java funkcijos, kurios pagerina išraiškingumą ir saugumą. **Records** pašalina nuobodžų, klaidoms jautrų standartinio kodo reikalavimą duomenų klasėse (ir garantuoja teisingą, nuoseklų `equals`/`hashCode` — sprendžiant tą dažnąją klaidą), tuo pačiu primušdami nekintamumą — DTO, vertės objektų ir duomenų modeliavimą padaro daug švaresniu. **Sealed klasės** leidžia uždaras, kontroliuojamas tipo hierarchijas, kurias kompilyatorius supranta, o tai — kartu su records ir pattern-matching `switch` — leidžia išsamiai, tipo saugiai tvarkyti fiksuotą variantų rinkinį (algebrinio duomenų tipus).

Kartu jie Java padaro glaustesnę, su nekintamumu pagal numatytas, ir galinčią saugesni domenės modeliavimą, kurio sena Java reikalavo daug daugiau kodo.

Jų žinojimas atspindi dabartinės Java sklandumą ir leidžia grynesniam, patikimesniam dizainui, kurio sena Java reikalavo daug daugiau kodo pasiekti.