Modern Java: Records, Sealed Types & Patterns

Modern Java (17 through 25) added features that change how you model data and control flow. Records, sealed types, and pattern matching together let you express algebraic data types - a precise, compiler-checked way to model "a value is one of these shapes" - that used to require verbose class hierarchies or unsafe casts.

Records: transparent immutable data

A record is a concise, immutable data carrier. One line generates the constructor, accessors, equals, hashCode, and toString:

record Point(int x, int y) {}                    // done: immutable, with equals/hashCode/toString
record Money(BigDecimal amount, String currency) {}

Records are the right default for DTOs, map keys, and any "just data" type - and, as you'll see, the components of algebraic data types.

Sealed types: a closed set of subtypes

A sealed interface or class restricts which types may implement or extend it. This turns an open hierarchy into a closed one the compiler understands completely:

// a Shape is exactly one of these three - nothing else can implement it
sealed interface Shape permits Circle, Rectangle, Triangle {}
record Circle(double radius) implements Shape {}
record Rectangle(double w, double h) implements Shape {}
record Triangle(double base, double height) implements Shape {}

Because the set is closed, the compiler knows every possible case - which pattern matching exploits.

Pattern matching: destructure and branch exhaustively

Pattern matching for switch tests a value's type and binds its data in one step, and record patterns destructure a record's components directly. Combined with sealed types, the switch is exhaustive - the compiler errors if you miss a case:

// exhaustive, destructuring switch over a sealed type
double area(Shape shape) {
    return switch (shape) {
        case Circle(double r)          -> Math.PI * r * r;
        case Rectangle(double w, double h) -> w * h;
        case Triangle(double b, double h)  -> 0.5 * b * h;
        // no default needed: the compiler knows these are ALL the shapes
    };
}

No casts, no instanceof chains, no forgotten case slipping through - and if you later add a Pentagon, every non-exhaustive switch fails to compile until you handle it. This is the algebraic-data- type style (a "sum of products") that functional languages have long had, now first-class in Java.