sealed types

the picture

you know how any class can implement your interface, so a method that takes a Shape can never be sure it has handled every kind of shape? you end up writing default -> throw new IllegalStateException("unknown shape") and hoping. sealed types replace the hope with a list.

think of a party with a guest list at the door. a normal interface is an open house: anyone can walk in, you'll never know the full list. a sealed interface is the guest list. and each guest decides about plus-ones: final means no plus-ones, sealed means "only these people", non-sealed means "bring whoever you like".

the rules

every permitted subclass has to pick one of three modifiers, out loud:

final

no subclasses at all. records and enums are implicitly final, so they need nothing.

sealed

closed again, with its own permits list. hierarchies can be sealed several levels deep.

non-sealed

open. anyone can extend this one. it's a deliberate escape hatch, and it's spelled with a hyphen because it's the first hyphenated keyword java ever got.

forget to pick, or try to sneak in a subclass that isn't on the list, and javac stops you:

class Circle implements Shape {}
error: sealed, non-sealed or final modifiers expected
 
final class Blob implements Shape {}
error: class is not allowed to extend sealed class: Shape (as it is not listed in its 'permits' clause)

the permitted subclasses have to live in the same module as the sealed type (or the same package, if you're not using modules). when they're all in the same file, you can leave permits out and the compiler fills it in:

import java.util.*;
 
sealed interface Shape {}                        // no permits: inferred from this file
record Circle(double r) implements Shape {}
record Square(double side) implements Shape {}
 
void main() {
    Shape s = new Square(2);
    String d = switch (s) {                      // no default needed
        case Circle c -> "circle " + c.r();
        case Square q -> "square " + q.side();
    };
    IO.println(d);
    IO.println(Shape.class.isSealed());
    IO.println(Arrays.toString(Shape.class.getPermittedSubclasses()));
}

square 2.0
true
[class Main$Circle, class Main$Square]

exhaustiveness

here's the reason sealed types exist. turn cases on and off, and see what javac thinks.

that second part is the whole point. when someone adds Triangle, every switch over Shape that doesn't handle it turns into a compile error, in every file, at once. the compiler hands you the to-do list. with a default, those switches would have compiled, and triangles would have quietly fallen into "something else".

why not an enum?

an enum is a closed set of instances: exactly one RED, one GREEN. a sealed type is a closed set of types, and each type can have as many instances as you like, each with its own data. Circle(1.0) and Circle(2.5) are both circles. that's why sealed interfaces and records go together so well: the sealed interface says "these are the shapes", the records say what each shape carries. the full pattern is data-oriented programming.