Sealed classes are a feature introduced in Java 17 to limit which classes or interfaces can inherit or implement it. Its core role is to enhance control over inheritance by explicitly declaring allowed subclasses. Specifically: 1. Addresses the problem that the subclasses were not restricted at the language level before; 2. Supports pattern matching (especially when combined with record classes); 3. Use sealed keywords and permits clauses to define allowed subclasses; 4. Subclasses must be declared final, sealed or non-sealed; 5. Applicable to closed type hierarchy, compile-time inspection and domain model design; 6. It should be noted that subclasses must be explicitly inherited in the same module or package. Sealing classes are suitable for scenarios that require strict inheritance control, but should not be abused.

Sealed classes in Java are a feature introduced in Java 17 that lets you restrict which other classes or interfaces can extend or implement them. In simple terms, they give you more control over inheritance by explicitly stating who is allowed to be a subclass.

This is useful when you want to define a class hierarchy that's both closed and well-known — like modeling types where only specific variations should exist.

What Problem Do Sealed Classes Solve?

Before sealed classes, if you wanted to limit which classes could extend yours, you had to rely on documentation or package-private visibility tricks. But there was no real language-level enforcement.

Now, with sealed classes:

• You can explicitly declare which subclasses are allowed.
• You avoid unexpected or unauthorized subclassing.
• It helps make pattern matching with switch statements more powerful (especially in combination with records).

For example:

 public sealed class Shape permits Circle, Rectangle, Triangle {
    // ...
}

This means only Circle , Rectangle , and Triangle can extend Shape . No one else.

How to Use Sealed Classes

Using sealed classes involves two main parts: defining the sealed class and declaring its allowed subclasses.

Here's how you do it:

1. Use the sealed modifier on the class.
2. Follow it with a permits clause listing the allowed subclasses.

Example:

 public sealed class Animal permits Cat, Dog, Bird {
    // common behavior
}

Each of those subclasses must then extend Animal and also be declared as either:

• final : If it shouldn't be extended further.
• sealed : If it allows some subclasses but not all.
• non-sealed : If it removes any restrictions on its children.

Like this:

 public final class Cat extends Animal { }

Or this:

 public sealed class Mammal extends Animal permits Human, Monkey { }

When Should You Use Them?

You'll find sealed classes most useful in these situations:

• You're building a closed type hierarchy (eg, expressions in a compiler, game entities).
• You want better compile-time checks for exhaustive pattern matching.
• You're using records and want to combine them with sealed hierarchies for clearer domain models.

They're especially handy when you're writing code like this:

 switch(shape) {
    case Circle c -> {...}
    case Rectangle r -> {...}
    case Triangle t -> {...}
}

Because the compiler knows exactly which subclasses exist, it can tell you if your switch is missing a case.

A Few Gotchas to Keep in Mind

There are a few small but important rules when working with sealed classes:

• All permitted subclasses must be in the same module (or package if in the unnamed module).
• Subclasses must explicitly extend the sealed parent.
• The sealing chain must be consistent — if a parent is sealed, each child must follow the same rules.

Also, while sealed classes are powerful, they're not always necessary. If your class hierarchy is open or likely to grow, sticking with a regular class makes more sense.

So unless you have a clear reason to seal a class, don't. But when you do need tight control over inheritance, they're a great tool.

Basically that's it.

The above is the detailed content of What are Sealed Classes in Java?. For more information, please follow other related articles on the PHP Chinese website!