密封類是Java 17引入的功能，用於限制哪些類或接口可以繼承或?qū)崿F(xiàn)它。其核心作用是通過(guò)顯式聲明允許的子類，增強(qiáng)對(duì)繼承的控制。具體來(lái)說(shuō)：1. 解決了此前無(wú)法在語(yǔ)言層面限制子類的問(wèn)題；2. 支持模式匹配（尤其是與記錄類結(jié)合時(shí)）；3. 使用sealed關(guān)鍵字和permits子句定義允許的子類；4. 子類必須聲明為final、sealed或non-sealed；5. 適用於封閉類型層級(jí)、編譯時(shí)檢查及領(lǐng)域模型設(shè)計(jì)；6. 需注意子類必須在同一模塊或包中且顯式繼承。密封類適合需要嚴(yán)格繼承控制的場(chǎng)景，但不應(yīng)濫用。

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 permitted 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.

基本上就這些。

以上是Java的密封課是什麼？的詳細(xì)內(nèi)容。更多資訊請(qǐng)關(guān)注PHP中文網(wǎng)其他相關(guān)文章！