Sealed Classes (Java 15+)

Sealed Classes were introduced as a preview feature in Java 15 and later became a standard feature in Java 17. They are designed to give developers better control over inheritance in Java.

With sealed classes, you can explicitly define which classes are allowed to extend or implement a particular class, making your code more secure and predictable.

What are Sealed Classes?

A sealed class is a special type of class in Java that restricts which other classes can extend it. Only the classes that are explicitly permitted are allowed to inherit from it.

In simple words: A sealed class lets you control and restrict inheritance so only selected classes can extend it.

Syntax of Sealed Class

sealed class Shape permits Circle, Rectangle {
}

👉 This means only Circle and Rectangle are allowed to extend the Shape class.

Why Sealed Classes Were Introduced?

Before sealed classes, any class could be extended freely in Java. This means there was no restriction on inheritance, which often caused design and maintenance issues in large applications.

Before sealed classes:

class Animal {}

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

Problems:

• No control over inheritance – any class could extend a parent class
• Design becomes unpredictable in large applications
• Difficult to maintain code structure
• Risk of unwanted or incorrect subclassing

Solution: Sealed Classes

Sealed classes were introduced to solve the problems of uncontrolled inheritance in Java. They allow developers to explicitly define which classes can extend a parent class, making the system more structured and secure.

Key Benefits

• Controlled inheritance – Only permitted classes can extend the sealed class
• Better security – Prevents unwanted or unsafe subclassing
• Clear class hierarchy – Makes relationships between classes well-defined
• Improved maintainability – Easier to manage and understand large codebases

permits Keyword

The permits keyword is used in sealed classes to define which subclasses are allowed to extend the parent class. It gives explicit control over inheritance and ensures only approved classes can inherit.

sealed class Shape permits Circle, Rectangle {
}

👉 This means only Circle and Rectangle are allowed to extend the Shape class.

Example of Sealed Class

Sealed classes allow only specific subclasses to extend them. Each permitted subclass must explicitly follow Java’s rules like final, sealed, or non-sealed.

Step 1: Sealed Class

sealed class Animal permits Dog, Cat {
}

Step 2: Subclasses

final class Dog extends Animal {
}

final class Cat extends Animal {
}

Rules of Sealed Classes

Sealed classes in Java follow some strict rules to ensure controlled and safe inheritance. These rules define how a class can be extended and how subclasses should behave.

1. Must use permits

A sealed class must explicitly specify which classes are allowed to extend it using the permits keyword.

sealed class Shape permits Circle, Square {
}

👉 This ensures only listed classes can inherit the sealed class.

2. Subclasses must follow one rule

Every subclass of a sealed class must declare its inheritance type clearly:

• final → Cannot be extended further
• sealed → Can be extended but in a controlled way
• non-sealed → Can be extended freely

sealed class Shape permits Circle, Square {
}

final class Circle extends Shape {
}

non-sealed class Square extends Shape {
}

Explanation:

• Circle is final, so no further inheritance is allowed
• Square is non-sealed, so it can be extended by any class

3. Subclasses must be in same module or package

All permitted subclasses must be defined in the same module or package as the sealed class. This ensures better encapsulation and control.

package shapes;

sealed class Shape permits Circle {
}

final class Circle extends Shape {
}

👉 If a subclass is outside the allowed package/module, Java will throw a compilation error.

Types of Subclasses

In sealed classes, every permitted subclass must define how inheritance will behave further. Java provides three different types of subclasses to control this behavior.

1. final subclass

A final subclass cannot be extended further. Once a class is declared final, it becomes the end of the inheritance chain.

final class Dog extends Animal {
}

👉 This means no other class can extend Dog.

2. sealed subclass

A sealed subclass continues to restrict inheritance by specifying which classes are allowed to extend it.

sealed class Cat extends Animal permits Persian {
}

👉 Only Persian class is allowed to extend Cat.

3. non-sealed subclass

A non-sealed subclass becomes open for inheritance, meaning any class can extend it freely.

non-sealed class Tiger extends Animal {
}

👉 This removes restrictions and allows unlimited inheritance.

Sealed Interface Example

The sealed feature in Java is not limited to classes only — it can also be applied to interfaces. This allows you to control which classes are allowed to implement the interface.

Example

sealed interface Vehicle permits Car, Bike {
}

final class Car implements Vehicle {
}

final class Bike implements Vehicle {
}

👉 In this example, only Car and Bike are allowed to implement the Vehicle interface.

Real-World Example

Sealed classes are very useful in real-world applications where you need to restrict and control behavior, such as payment systems.

Payment System Example

sealed class Payment permits CardPayment, UPIPayment {
}

final class CardPayment extends Payment {
}

final class UPIPayment extends Payment {
}

👉 In this example, only CardPayment and UPIPayment are allowed as valid payment methods. No other class can extend Payment, which ensures controlled and secure design.

Benefits of Sealed Classes

Sealed classes provide better control over inheritance, making Java applications more structured and secure. They are especially useful in large and complex systems where class hierarchy needs to be strictly managed.

• Controlled inheritance – Only permitted classes can extend.
• Better security – Prevents unwanted or unsafe subclassing.
• Clear architecture – Well-defined and predictable class structure.
• Easier maintenance – Reduces complexity in large codebases.
• Better domain modeling – Helps design real-world systems more accurately.

Limitations

Although powerful, sealed classes are not always suitable for every situation.

• Requires planning – Need to define hierarchy carefully in advance.
• Increases complexity in small apps – Unnecessary for simple projects.
• Less flexible than normal inheritance – Restricts open extension.

Difference Between Sealed vs Normal Class

Difference Between Sealed vs Final vs Normal Classes

Real-World Use Cases

Sealed classes are widely used in real-world applications where you need controlled inheritance and strict system design. They help in building safe and predictable architectures.

• Banking systems – To control different account or transaction types
• Payment methods – Like Card, UPI, NetBanking with fixed options
• Role-based systems – Defining strict user roles (Admin, User, Guest)
• State management – Managing fixed states in applications (Success, Failure, Pending)
• Domain modeling – Designing real-world business entities with controlled hierarchy

Example (Notification System)

Sealed classes are very useful in systems where the types are fixed, such as notification services. In this example, we define a limited set of notification types that are allowed.

Sealed Class

sealed class Notification permits Email, SMS, Push {
}

Subclasses

final class Email extends Notification {
}

final class SMS extends Notification {
}

non-sealed class Push extends Notification {
}

here:

• Email and SMS are fixed and cannot be extended further
• Push is open for extension if needed

When to Use Sealed Classes?

Sealed classes are useful when you want strict control over inheritance and a well-defined class structure. They are mainly designed for large and structured applications.

• When you need a fixed class hierarchy (limited and controlled subclasses)
• When modeling domain rules where behavior must be restricted
• When security and control over inheritance matters in system design

When NOT to Use Sealed Classes?

Sealed classes are not suitable for every scenario, especially when flexibility is more important than strict structure.

• Small projects – Unnecessary complexity for simple applications
• Highly dynamic systems – Where classes change frequently
• Rapid prototyping – Slows down quick development and testing

Conclusion

Sealed Classes in Java provide a powerful way to control inheritance and design more predictable class hierarchies.

They are especially useful in modern Java applications where structure, safety, and maintainability are important.

• Helps restrict class hierarchy for better control
• Improves security and design safety
• Enables clean and well-structured system architecture

👉 Overall, sealed classes are an important feature of modern Java (Java 17+), widely used in enterprise-level applications and domain-driven design.