Ce sunt înregistrările și clasele sigilate?

Question

Accepted Answer

**Înregistrările** (Java 16+) sunt purtători de date concizi și imuabili care generează automat codul standard, iar **clasele sigilate** (Java 17+) restricționează care clase pot extinde/implementa un tip. Ambele sunt caracteristici moderne care fac Java mai expresiv și permit modelarea mai bună.

## Înregistrări — date imuabile, fără cod standard

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

O înregistrare generează automat constructorul, accesorii, `equals()`, `hashCode()` și `toString()` din componentele sale. Câmpurile sunt **final** (imuabile) — înregistrările sunt proiectate pentru purtători de date transparenți și imuabili (DTO-uri, obiecte de valoare, coordonate).

## Înregistrările pot avea validare și metode

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

## Clasele sigilate — moștenire controlată

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

Un tip `sealed` enumeră explicit subtipurile sale permise — controlezi setul complet de implementări, pe care compilatorul le impune. Aceasta modelează o **ierarhie închisă** (un set fix și cunoscut de variante).

## Sigilate + înregistrări + potrivire model = modelarea puternică

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

Deoarece subtipurile unui tip sigilat sunt cunoscute și finite, compilatorul poate verifica că un `switch` este **exhaustiv** — capturând cazurile lipsă. Combinat cu înregistrări și potrivire model, aceasta aduce modelarea în stil tip de date algebrice în Java.

## De ce este important

Înregistrările și clasele sigilate sunt caracteristici Java moderne semnificative care îmbunătățesc expresivitatea și siguranța. **Înregistrările** elimină codul standard obositor și predispus la erori al claselor de date (și garantează `equals`/`hashCode` corect și consecvent — rezolvând acea capcană comună) în timp ce impun imutabilitate — făcând DTO-uri, obiecte de valoare și modelarea datelor mult mai curate. **Clasele sigilate** permit ierarhii de tip închise și controlate pe care compilatorul le înțelege, ceea ce — combinat cu înregistrări și `switch` cu potrivire model — permite manipularea exhaustivă și sigură din punct de vedere al tipului a unui set fix de variante (tipuri de date algebrice).

Împreună, ele fac Java mai concis, imuabil în mod implicit și capabil de modelarea domeniului mai sigură.

A le cunoaște reflectă o fluență cu Java-ul actual și permite proiecte mai curate și mai robuste pe care Java-ul mai vechi a necesitat mult mai mult cod pentru a le realiza.