Sealed Classes (Java 17+)

#Introduction

Sealed Classes are one of the most important features introduced in modern Java. They were introduced as a preview in Java 15 and became a standard feature in Java 17 (LTS).

A Sealed Class allows you to control which classes are allowed to extend or implement it.

Before Sealed Classes, any class could freely extend another class:

class Animal {
}
class Dog extends Animal {
}
class Cat extends Animal {
}
class Lion extends Animal {
}
class Tiger extends Animal {
}

There is no restriction. Sometimes this is undesirable. Java introduced Sealed Classes to solve this problem.

#What is a Sealed Class?

A Sealed Class restricts inheritance. Only the explicitly permitted classes can extend it.

public sealed class Vehicle
        permits Car, Bike, Truck {

}

Only Car, Bike and Truck can extend Vehicle. Any other class trying to extend it results in a compilation error.

#Why Do We Need Sealed Classes?

Imagine a banking application:

You don't want developers creating CryptoAccount, FakeAccount or UnknownAccount. Sealed classes prevent unauthorized inheritance.

#Syntax

public sealed class Animal
        permits Dog, Cat {

}

Permitted subclasses:

final class Dog extends Animal {
}
final class Cat extends Animal {
}

#Rules of Sealed Classes

Every permitted subclass must declare one of these modifiers:

• final
• sealed
• non-sealed

This is mandatory.

1. final

Inheritance stops completely.

public sealed class Animal
        permits Dog {

}

public final class Dog
        extends Animal {
}

Now:

class Puppy extends Dog {   // Compilation Error
}

2. sealed

Inheritance continues, but remains controlled.

public sealed class Animal
        permits Dog {

}

public sealed class Dog
        extends Animal
        permits Labrador, Pug {

}

Only Labrador and Pug may extend Dog.

3. non-sealed

Inheritance becomes unrestricted again.

public sealed class Animal
        permits Dog {

}

public non-sealed class Dog
        extends Animal {
}

Now both of these are allowed:

class Labrador extends Dog {
}
class GermanShepherd extends Dog {
}

#Complete Hierarchy

#Sealed Interfaces

Interfaces can also be sealed.

public sealed interface Payment
        permits CardPayment,
                UpiPayment,
                WalletPayment {

}

Implementation:

public final class CardPayment
        implements Payment {

}

#Reflection Support

Check whether a class is sealed:

System.out.println(
        Vehicle.class.isSealed()
);

true

Get permitted subclasses:

Vehicle.class.getPermittedSubclasses();

Useful for frameworks and code analysis tools.

#Sealed Classes with Switch

Sealed classes work well with pattern matching.

public sealed interface Shape
        permits Circle, Rectangle {

}

public final class Circle
        implements Shape {

}

public final class Rectangle
        implements Shape {

}

Because all possible subclasses are known, the compiler can verify switch exhaustiveness.

#Sealed Class vs final Class

#Sealed Class vs Abstract Class

A class can be both abstract and sealed:

public abstract sealed class Vehicle
        permits Car, Bike {

}

#Sealed Class vs Enum

Enum:

enum Status {
    ACTIVE,
    INACTIVE
}

Sealed:

sealed class Shape
        permits Circle, Rectangle {

}

#Real Project Examples

Compiler AST

Compilers often use sealed hierarchies because the set of node types is fixed.

#Limitations

• Permitted subclasses must follow module/package rules (same module, or same package in the unnamed module).
• More restrictive than normal inheritance.
• Not suitable when third-party extensions are expected.