Qu'est-ce que les records et les classes sealed ?

Question

Accepted Answer

**Les records** (Java 16+) sont des transporteurs de données concis et immuables qui génèrent automatiquement le boilerplate, et **les classes sealed** (Java 17+) restreignent quelles classes peuvent étendre/implémenter un type. Les deux sont des fonctionnalités modernes qui rendent Java plus expressif et permettent une meilleure modélisation.

## Records — données immuables, zéro 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 génère automatiquement le constructeur, les accesseurs, `equals()`, `hashCode()` et `toString()` à partir de ses composants. Les champs sont **final** (immuables) — les records sont conçus pour être des transporteurs de données transparents et immuables (DTOs, objets de valeur, coordonnées).

## Les records peuvent avoir une validation et des méthodes

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

## Classes sealed — héritage contrôlé

```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 type `sealed` énumère explicitement ses sous-types autorisés — vous contrôlez l'ensemble complet des implémentations, ce que le compilateur impose. Cela modélise une **hiérarchie fermée** (un ensemble fixe et connu de variantes).

## Sealed + records + pattern matching = modélisation puissante

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

Parce que les sous-types d'un type sealed sont connus et finis, le compilateur peut vérifier qu'un `switch` est **exhaustif** — détectant les cas manquants. Combiné avec les records et le pattern matching, cela apporte un style de modélisation de type algébrique à Java.

## Pourquoi c'est important

Les records et les classes sealed sont des fonctionnalités Java modernes significatives qui améliorent l'expressivité et la sécurité. **Les records** éliminent le boilerplate fastidieux et sujet aux erreurs des classes de données (et garantissent des `equals`/`hashCode` corrects et cohérents — résolvant ce piège courant) tout en imposant l'immuabilité — rendant les DTOs, objets de valeur et modélisation de données beaucoup plus propres. **Les classes sealed** permettent des hiérarchies de types fermées et contrôlées que le compilateur comprend, ce qui — combiné avec les records et le `switch` avec pattern matching — permet une gestion exhaustive et type-safe d'un ensemble fixe de variantes (types de données algébriques).

Ensemble, elles rendent Java plus concis, immuable par défaut, et capable d'une modélisation de domaine plus sûre que ce que Java plus ancien nécessitait beaucoup plus de code pour réaliser.

Les connaître reflète une maîtrise du Java actuel et permet des conceptions plus propres et plus robustes que les versions précédentes de Java nécessitaient beaucoup plus de code pour atteindre.