Records, sealed types, and pattern matching

A record is a class whose whole state is its components: record Money(long cents, String currency) {} gets a canonical constructor, accessors cents() and currency(), and equals, hashCode and toString over both components. Its fields are final, it cannot extend another class (it implicitly extends java.lang.Record), and it can implement interfaces. A compact constructor — no parameter list — runs before the fields are assigned and is where validation and normalisation go.

Sealed interfaces

A sealed interface lists exactly which classes may implement it:

sealed interface Notification permits Email, Sms, Push {}
record Email(String to, String subject) implements Notification {}
record Sms(String number, String text) implements Notification {}
record Push(String device, int badge) implements Notification {}

Nobody else can add a fourth kind. (The permitted subclasses must be final, sealed or non-sealed; records are implicitly final.) That closed set is what makes the next part work: the compiler knows every possible case.

Pattern matching in switch

Java 21 lets a switch match on the type of a value and take a record apart in the same step, with record patterns. A when clause adds a condition to a case.

Because Notification is sealed, a switch that covers Email, Sms and Push is exhaustive with no default — and if a fourth record is ever permitted, every such switch stops compiling until it handles it. This is the data-oriented alternative to adding a virtual method to each class: the operation lives in one place, and the compiler checks that it handles every case.

Cases are tried top to bottom, so a guarded case must come before the unguarded case for the same type; the compiler rejects a case that an earlier one makes unreachable ("dominated").

instanceof gained the same power: if (n instanceof Sms(var number, var text)) tests the type and binds the components at once, with no cast.

Common mistakes

• Switching on a value that may be null. Unless the switch has a case null, it throws NullPointerException immediately, whatever the other cases are.
• Putting the unguarded case Sms s above case Sms s when ... — a compile error, because the guarded case could never run.
• Adding a default to a switch over a sealed type "to be safe". It compiles, and silently turns off the check that would have flagged a newly added subtype.
• Writing this.currency = ... inside a compact constructor. That is a compile error: the fields are assigned automatically at the end, so normalise by reassigning the parameter (), as the first example does.

What interviewers ask

• What does a record generate, and what can't it do? Constructor, accessors, equals/hashCode/toString; it cannot extend a class or declare extra instance fields.
• Why seal an interface? To make the set of implementations closed and known, so switches over it are checked for exhaustiveness and the domain model says exactly what can exist.
• What is a record pattern? A pattern like Point(int x, int y) that matches a record type and binds its components, and can nest.