Java records, sealed types and pattern matching for switch

What it is

JEP 395 describes a record as a class that acts as a transparent carrier for immutable data. record Point(int x, int y) {} declares the components; the compiler derives a canonical constructor, a public accessor per component (x(), not getX()), and equals, hashCode and toString over all components. A record is implicitly final, cannot extend another class and cannot declare instance fields beyond its components. A compact constructor, written without a parameter list, validates or normalises the arguments before they are assigned.

JEP 409 adds sealed classes and interfaces: sealed interface Shape permits Circle, Square {} names the only permitted direct subtypes, each of which must be final, sealed or non-sealed, and all of which must live in the same module (or the same package in the unnamed module). Records are implicitly final, so they are natural permitted subtypes.

JEP 441 (JDK 21) lets switch use type patterns (case Circle c -> ...), guards (case Circle c when c.radius() > 0), case null, and record deconstruction patterns. A pattern switch must be exhaustive: over a sealed type it needs no default when every permitted subtype has a case, and the compiler rejects an incomplete one.

Why it matters

Engineers arriving from Rust, Kotlin, Swift or TypeScript expect algebraic data types and exhaustive matching. Before these features Java modelled "one of several shapes" with a class hierarchy plus instanceof chains, and the compiler could not report an unhandled variant. With a sealed hierarchy, adding a permitted subtype turns every exhaustive switch without default into a compile error until it is updated.

How to apply

• Use records for values: DTOs, map keys, results, events. Validate in the compact constructor and throw for invalid arguments.
• Model a closed set of alternatives as a sealed interface whose permitted types are records; keep the whole hierarchy in one file or package.
• Prefer switch expressions with pattern labels to instanceof chains, and omit default deliberately so the compiler enforces coverage.
• Keep records shallowly immutable on purpose: a record holding a List still exposes a mutable list unless the constructor copies it (List.copyOf).
• Records serialise by their components and deserialise through the canonical constructor, so the validation there also guards deserialisation.

Pitfalls

A record's equals uses all components, which is wrong for entities with identity. A default arm in a pattern switch silently hides missing cases. Pattern switch needs JDK 21 (records need 16, sealed types 17). JEP 441 notes that a pattern switch which finds no matching label at run time, for example after a separately compiled sealed hierarchy gained a subtype, throws MatchException.