O que são records e sealed classes?

Question

Accepted Answer

**Records** (Java 16+) são transportadores de dados concisos e imutáveis que geram automaticamente código padrão, e **sealed classes** (Java 17+) restringem quais classes podem estender/implementar um tipo. Ambos são recursos modernos que tornam Java mais expressivo e permitem melhor modelagem.

## Records — dados imutáveis, zero código padrão

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

Um record gera automaticamente o construtor, acessadores, `equals()`, `hashCode()` e `toString()` a partir de seus componentes. Os campos são **final** (imutáveis) — records são projetados como transportadores de dados transparentes e imutáveis (DTOs, value objects, coordenadas).

## Records podem ter validação e 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
}
```

## Sealed classes — herança 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
```

Um tipo `sealed` lista explicitamente seus subtipos permitidos — você controla o conjunto completo de implementações, que o compilador garante. Isso modela uma **hierarquia fechada** (um conjunto fixo e conhecido de variantes).

## Sealed + records + pattern matching = modelagem poderosa

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

Porque os subtipos de um tipo sealed são conhecidos e finitos, o compilador pode verificar se um `switch` é **exaustivo** — capturando casos ausentes. Combinado com records e pattern matching, isso traz modelagem no estilo de tipos de dados algébricos para Java.

## Por que isso importa

Records e sealed classes são recursos Java modernos significativos que melhoram expressividade e segurança. **Records** eliminam o tedioso e propenso a erros código padrão de classes de dados (e garantem `equals`/`hashCode` corretos e consistentes — resolvendo essa armadilha comum) enquanto impõem imutabilidade — tornando DTOs, value objects e modelagem de dados muito mais limpos. **Sealed classes** habilitam hierarquias de tipo fechadas e controladas que o compilador entende, o que — combinado com records e `switch` com pattern matching — permite tratamento exaustivo e type-safe de um conjunto fixo de variantes (tipos de dados algébricos).

Juntos, eles tornam Java mais conciso, imutável por padrão e capaz de modelagem de domínio mais segura do que Java antigo exigia muito mais código para alcançar.

Conhecer esses recursos reflete fluência com Java atual e habilita designs mais limpos e robustos que versões antigas de Java exigiriam muito mais código para alcançar.