> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Java Sealed Interface
A sealed interface is an interface that restricts which classes or interfaces may directly implement or extend it. By using the `sealed` modifier in conjunction with the `permits` clause, a sealed interface explicitly defines an exhaustive list of allowed subtypes at compile time, providing strict, compiler-enforced control over the inheritance hierarchy.
## Syntax Declaration
To declare a sealed interface, apply the `sealed` modifier before the `interface` keyword. Following the interface name (and any generic type parameters), use the `permits` keyword followed by a comma-separated list of the fully qualified or simple names of the allowed subtypes.
```java theme={"dark"}
public sealed interface Shape permits Circle, Rectangle, Polygon {
double calculateArea();
}
```
If the permitted subtypes are declared within the same source file as the sealed interface, the `permits` clause can be omitted. The Java compiler will automatically infer the permitted subtypes from the file's contents.
## Subtype Constraints and Rules
The Java compiler enforces strict rules on any class or interface listed in the `permits` clause of a sealed interface:
1. **Module and Package Restrictions:** Permitted subtypes must reside in the same module as the sealed interface. If the interface is declared in an unnamed module, the permitted subtypes must reside in the same package.
2. **Direct Implementation:** Every permitted subtype must directly implement or extend the sealed interface.
3. **Mandatory Modifiers:** Every permitted subtype must explicitly declare exactly one of three inheritance modifiers to define how the hierarchy continues:
* `final`: Prevents any further extension. *(Note: This is only applicable to implementing classes, as interfaces cannot be declared `final`.)*
* `sealed`: Continues the restriction, requiring the subtype to define its own `permits` clause.
* `non-sealed`: Re-opens the hierarchy, allowing any unknown class or interface to extend or implement this specific subtype.
## Subtype Implementation Examples
The following code demonstrates how permitted subtypes must apply the mandatory modifiers when implementing or extending a sealed interface:
```java theme={"dark"}
// 1. A final class implementing the sealed interface
public final class Circle implements Shape {
public double calculateArea() {
return Math.PI * 10 * 10;
}
}
// 2. A sealed interface extending the parent sealed interface
public sealed interface Rectangle extends Shape permits Square {
double getWidth();
double getHeight();
}
// 3. A non-sealed class implementing the sealed interface
public non-sealed class Polygon implements Shape {
public double calculateArea() {
return 0.0;
}
}
```
## Integration with Record Classes
Java Records are implicitly `final`. When a record implements a sealed interface, it satisfies the mandatory modifier requirement without needing an explicit `final` declaration.
```java theme={"dark"}
public sealed interface Command permits PrintCommand {}
// The record is implicitly final, satisfying the sealed hierarchy rules
public record PrintCommand(String text) implements Command {}
```
Tired of Poor Java Skills? Fix That With Deep Grasping!
Learn More
