What are records and sealed classes?

Question

Accepted Answer

**Records** (Java 16+) are concise, immutable data carriers that auto-generate boilerplate, and **sealed classes** (Java 17+) restrict which classes can extend/implement a type. Both are modern features that make Java more expressive and enable better modeling.

## Records — immutable data, 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
```

A record auto-generates the constructor, accessors, `equals()`, `hashCode()`, and `toString()` from its components. The fields are **final** (immutable) — records are designed for transparent, immutable data carriers (DTOs, value objects, coordinates).

## Records can have validation and methods

```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 — controlled inheritance

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

A `sealed` type explicitly lists its permitted subtypes — you control the complete set of implementations, which the compiler enforces. This models a **closed hierarchy** (a fixed, known set of variants).

## Sealed + records + pattern matching = powerful modeling

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

Because a sealed type's subtypes are known and finite, the compiler can verify a `switch` is **exhaustive** — catching missing cases. Combined with records and pattern matching, this brings algebraic-data-type style modeling to Java.

## Why it matters

Records and sealed classes are significant modern Java features that improve expressiveness and safety. **Records** eliminate the tedious, error-prone boilerplate of data classes (and guarantee correct, consistent `equals`/`hashCode` — solving that common pitfall) while enforcing immutability — making DTOs, value objects, and data modeling far cleaner. **Sealed classes** enable closed, controlled type hierarchies that the compiler understands, which — combined with records and pattern-matching `switch` — allows exhaustive, type-safe handling of a fixed set of variants (algebraic data types).

Together they make Java more concise, immutable-by-default, and capable of safer domain modeling.

Knowing them reflects fluency with current Java and enables cleaner, more robust designs that older Java required much more code to achieve.