Cosa sono i record e le classi sealed?

Question

Accepted Answer

**Record** (Java 16+) sono carrier di dati concisi e immutabili che auto-generano il boilerplate, e le **classi sealed** (Java 17+) limitano quali classi possono estendere/implementare un tipo. Entrambi sono feature moderne che rendono Java più espressivo e permettono una migliore modellazione.

## Record — dati immutabili, zero 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
```

Un record auto-genera il costruttore, gli accessor, `equals()`, `hashCode()` e `toString()` dai suoi componenti. I campi sono **final** (immutabili) — i record sono progettati per essere carrier di dati trasparenti e immutabili (DTO, value object, coordinate).

## I record possono avere validazione e metodi

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

## Classi sealed — eredità controllata

```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 tipo `sealed` lista esplicitamente i suoi sottotipi permessi — tu controlli l'insieme completo delle implementazioni, che il compilatore applica. Questo modella una **gerarchia chiusa** (un set fisso e noto di varianti).

## Sealed + record + pattern matching = modellazione potente

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

Poiché i sottotipi di un tipo sealed sono noti e finiti, il compilatore può verificare che uno `switch` sia **esaustivo** — catturando i casi mancanti. Combinato con record e pattern matching, questo porta la modellazione in stile algebraic-data-type a Java.

## Perché è importante

I record e le classi sealed sono significative feature moderne di Java che migliorano l'espressività e la sicurezza. I **record** eliminano il tedioso e soggetto a errori boilerplate delle classi di dati (e garantiscono `equals`/`hashCode` corretti e consistenti — risolvendo quel pitfall comune) mentre impongono l'immutabilità — rendendo i DTO, i value object e la modellazione dei dati molto più puliti. Le **classi sealed** abilitano gerarchie di tipi chiuse e controllate che il compilatore comprende, il che — combinato con record e `switch` con pattern-matching — permette la gestione esaustiva e type-safe di un insieme fisso di varianti (algebraic data type).

Insieme rendono Java più conciso, immutable-by-default, e capace di modellazione di dominio più sicura che il Java più vecchio richiedeva molto più codice per ottenere.

Conoscerli riflette familiarità con Java attuale e abilita design più puliti e robusti che le versioni più vecchie di Java richiedevano molto più codice per realizzare.