¿Qué son los records y las clases selladas?

Question

Accepted Answer

**Records** (Java 16+) son transportadores de datos concisos e inmutables que generan automáticamente código repetitivo, y **sealed classes** (Java 17+) restringen qué clases pueden extender/implementar un tipo. Ambas son características modernas que hacen Java más expresivo y permiten un mejor modelado.

## Records — datos inmutables, cero código repetitivo

```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 genera automáticamente el constructor, los accesores, `equals()`, `hashCode()` y `toString()` a partir de sus componentes. Los campos son **final** (inmutables) — los records están diseñados para transportadores de datos transparentes e inmutables (DTOs, objetos de valor, coordenadas).

## Los records pueden tener validación y métodos

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

## Clases selladas — herencia controlada

```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` enumera explícitamente sus subtipos permitidos — controlas el conjunto completo de implementaciones, que el compilador refuerza. Esto modela una **jerarquía cerrada** (un conjunto fijo y conocido de variantes).

## Sealed + records + pattern matching = modelado poderoso

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

Dado que los subtipos de un tipo sealed son conocidos y finitos, el compilador puede verificar que un `switch` sea **exhaustivo** — capturando casos faltantes. Combinado con records y pattern matching, esto aporta un modelado de tipo algebraico a Java.

## Por qué es importante

Los records y las clases selladas son características modernas significativas de Java que mejoran la expresividad y la seguridad. **Los records** eliminan el tedioso y propenso a errores código repetitivo de las clases de datos (y garantizan `equals`/`hashCode` correctos y consistentes — resolviendo ese escollo común) mientras aplican inmutabilidad — haciendo los DTOs, objetos de valor y modelado de datos mucho más limpios. **Las clases selladas** permiten jerarquías de tipos cerradas y controladas que el compilador entiende, lo que — combinado con records y `switch` con pattern matching — permite un manejo exhaustivo y type-safe de un conjunto fijo de variantes (tipos de datos algebraicos).

Juntos hacen Java más conciso, inmutable-por-defecto, y capaz de un modelado de dominio más seguro que el código anterior de Java requería mucho más para lograr.

Conocerlos refleja fluidez con el Java actual y permite diseños más limpios y robustos que las versiones anteriores de Java requerían mucho más código para conseguir.