sealed classes are a feature that was previously introduced in JDK 15 and formally in JDK 17. A sealed class is a class that cannot be extended by classes that are not explicitly allowed (in the class declaration), so the number of subclasses is limited and known in advance.

They are intended to allow more precise control over the inheritance hierarchy, as well as facilitate the modeling of domains where all possible subclasses are known, and improve the security and maintainability of the code.

The difference between a sealed class and a class of the final type is that the latter cannot be extended by any class, while a sealed class can be extended by a limited number of classes.

Declaration of a sealed class

Suppose we have two classes, a Shape class and a Circle class, both are normal classes, so Shape can be extended by any class.

public class Shape {
    // ...
}

public class Circle extends Shape {
    // ...
}

If we use the final keyword in the Shape class, then it cannot be extended by any class.

public final class Shape {
    // ...
}

public class Circle extends Shape { // Error
    // ...
}

Now, if we want the Shape class to be extended only by certain classes (for example, Circle and Square), then we can declare it as a sealed class.

public sealed class Shape permits Circle, Square {
    // ...
}

Analyzing the previous declaration, we see that it is necessary to place sealed before the word class to indicate that it is a sealed class. Then, the word permits is used followed by a list of classes that can extend the current class, in the example above, only the Circle and Square classes can extend the Shape class.

The same thing happens if you work with a class of the abstract type, that is, a class that cannot be instantiated, but that can be extended by other classes.

public sealed abstract class Shape permits Circle, Square {
    // ...
}

This concept can also be applied to interfaces.

public sealed interface Shape permits Circle, Square {
    // ...
}

Note: Allowed subclasses must be within the same module or package as the sealed class, otherwise an error message will be displayed.

Allowed classes

Once a class has been declared sealed and the allowed classes have been specified, when extending the Shape class with an allowed class (by placing extends Shape) the IDE will display an error message similar to this Modifier 'sealed', 'non-sealed' or 'final' expected, What does this mean?.

It must be taken into consideration that each of the allowed classes (subclasses) must be declared with one of the following keywords:

• final: Indicates that the class cannot be extended.
• sealed: Indicates that the class is a sealed class and that it has allowed subclasses.
• non-sealed: Indicates that the class is not a sealed class and that it can be extended by any class.

To put the above into practice, let's work with the Shape class and the Circle, Square and Triangle classes to see how the allowed classes can be declared according to what was mentioned above.

public class Shape {
    // ...
}

public class Circle extends Shape {
    // ...
}

Circle class - final

If we want the Circle class to be of the final type and consequently cannot be extended, then it must be declared as follows:

public final class Shape {
    // ...
}

public class Circle extends Shape { // Error
    // ...
}

This prevents the Circle class from being extended by any other class.

Square class - sealed

If we want the Square class to be of type sealed and have allowed subclasses that can extend it, then it must be declared as follows:

public sealed class Shape permits Circle, Square {
    // ...
}

For this example, each of the allowed classes (SquareChild1 and SquareChild2) are declared of type final so that they cannot be extended by any other class.

public sealed abstract class Shape permits Circle, Square {
    // ...
}

If you want these classes to be able to be extended by more classes, then they should be declared as sealed or that they can be extended by any class with non-sealed.

Triangle class - non-sealed

In the case of the Triangle class, when it is declared non-sealed, it allows this class to be extended by any other class, without the need to specify the allowed classes.

public sealed interface Shape permits Circle, Square {
    // ...
}

For example, if you create the TriangleChild class that extends Triangle, no error message will be displayed.

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

At this point it is important to consider that if you declare a class as non-sealed you "break" in a certain way the purpose of the sealed classes, since it allows this class be extended by any other class and the number of allowed subclasses is not limited.

Can a record be a sealed class?

For its part, a record cannot be of the sealed type since it is already of the final type and cannot be extended by any other class. But what you can do is declare a record as allowed in a interface of the sealed type (consider that a record cannot extend a class, only implement interfaces). For example, if you have a record called Rectangle and a Shape interface of type sealed, you can declare Rectangle as allowed in the Shape interface and in this way Rectangle will be able to implement the Shape interface and all the methods that this interface contains.

public class Shape {
    // ...
}

public class Circle extends Shape {
    // ...
}

What about inner classes?

If a class declared as sealed has inner classes (nested or inner classes), it is assumed that these classes belong to the main class and, therefore, it is not necessary to declare them as allowed. For example, if you have the class Animal declared as sealed and at the same time it has Dog and Cat as internal classes, these classes do not need to be declared as allowed, but they must extend the main class and be of the final type, sealed or non-sealed. .

public final class Shape {
    // ...
}

public class Circle extends Shape { // Error
    // ...
}

Conclusions

The sealed classes are a way of limiting a class hierarchy to a finite number of allowed subclasses, although we have seen that if a class is declared non-sealed the purpose is somewhat lost or By declaring a subclass as sealed you can extend this hierarchy even further.

It is important to consider that when declaring a class as sealed this only refers to who can extend it, but does not limit the creation of instances of the main class, nor does it modify the semantics of the class, that is, it is not modifies the internal behavior of the class.

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