Java Sealed Classes Cheat Sheet

public sealed interface Shape    permits Circle, Square, Rectangle {}public final class Circle implements Shape {    public final double radius;    public Circle(double radius) { this.radius = radius; }}public final class Square implements Shape {    public final double side;    public Square(double side) { this.side = side; }}// Permitted subclasses must be final, sealed, or non-sealedpublic non-sealed class Rectangle implements Shape {    public double width, height;}

// If all permitted subtypes live in the same source file, permits can be omittedsealed interface Result<T> {    record Ok<T>(T value) implements Result<T> {}    record Err<T>(String message) implements Result<T> {}}

static double area(Shape shape) {    return switch (shape) {        case Circle c -> Math.PI * c.radius * c.radius;        case Square s -> s.side * s.side;        case Rectangle r -> r.width * r.height;        // no default clause required: compiler proves exhaustiveness    };}// With record patterns (deconstruction)static String describe(Result<Integer> result) {    return switch (result) {        case Result.Ok<Integer> ok -> "value: " + ok.value();        case Result.Err<Integer> err -> "error: " + err.message();    };}

public sealed interface Shape permits Circle, Square, Rectangle {}// java.lang.Class exposes sealed metadata via reflectionClass<?> clazz = Shape.class;boolean sealed = clazz.isSealed();                 // trueClass<?>[] permitted = clazz.getPermittedSubclasses();for (Class<?> c : permitted) {    System.out.println(c.getName());}// Useful for building generic serializers/validators that must stay// in sync with the hierarchy without hardcoding subtype lists.// A non-sealed class reports isSealed() == false even if its supertype is sealedSystem.out.println(Rectangle.class.isSealed());   // false

sealed interface Result<T> permits Result.Ok, Result.Err {    record Ok<T>(T value) implements Result<T> {}    record Err<T>(String message, int code) implements Result<T> {}}static String describe(Result<Integer> result) {    return switch (result) {        // Guarded pattern: 'when' adds a boolean condition after the match        case Result.Ok<Integer> ok when ok.value() > 100 -> "big win: " + ok.value();        case Result.Ok<Integer> ok -> "ok: " + ok.value();        // Nested record pattern: deconstruct straight into the record's components        case Result.Err<Integer>(String msg, int code) when code >= 500 -> "server error: " + msg;        case Result.Err<Integer>(String msg, int code) -> "client error " + code + ": " + msg;    };}// If a 'when' guard doesn't match, the compiler falls through to the next label// in source order -- guarded patterns do NOT count toward exhaustiveness on their own.

// permits accepts fully-qualified names across packages, but every permitted// subtype must be co-located with the sealed type: same module (named modules)// or same package (unnamed/classpath scenarios).package com.example.shapes;public sealed interface Shape    permits com.example.shapes.circles.Circle,            com.example.shapes.polygons.Square {}// module-info.java for a named-module project must still expose both packagesmodule com.example.app {    exports com.example.shapes;    exports com.example.shapes.circles;    exports com.example.shapes.polygons;}// Compile error if a permitted class lives in an unrelated module:// "class Circle is not allowed to extend sealed class Shape: module//  com.example.app does not contain it"

sealed interface Container<T> permits Box, Empty {}record Box<T>(T value) implements Container<T> {}record Empty<T>() implements Container<T> {}// Pattern matching on a generic sealed type only checks the raw/permitted type,// not the type argument -- the compiler can't prove exhaustiveness across T.static <T> String show(Container<T> c) {    return switch (c) {        case Box<T> b -> "box: " + b.value();        case Empty<T> e -> "empty";        // exhaustive over Container's permitted subtypes regardless of T    };}// Beware: you cannot add a type-argument-specific permits list (e.g. permits// Box<String>) -- sealing is enforced on the raw type; generics are erased// for this purpose just like everywhere else in the JVM.