Home Java javaTutorial Sealed class rules in Java

Sealed class rules in Java

Oct 08, 2024 pm 10:12 PM

Sealed class rules in Java

Sealed classes are a new feature introduced in Java versions 15 and above, designed to provide more control and flexibility over class inheritance within a module. A sealed class imposes certain constraints on its subclasses, allowing for a restricted and organized structure of class hierarchy.

To begin, a sealed class and its subclasses must belong to the same module, or if declared in an unnamed module, the same package. This ensures that all classes within a sealed class's hierarchy are accessible and manageable within a specific environment.

Furthermore, every permitted subclass must directly extend the sealed class. This ensures a clear and concise hierarchy, without any subclasses branching out in an unexpected way.

Next, every permitted subclass must choose a modifier to describe how it continues the sealing initiated by its superclass. There are three options for these modifiers:

1) Final: This modifier makes the subclass the final level in the class hierarchy, prohibiting any further extension.

2) Sealed: This modifier allows the subclass to be extended further, but in a restricted fashion. All subclasses of a sealed subclass must be explicitly permitted by the sealed superclass.

3) Non-sealed: This modifier reverts the subclass's part of the hierarchy to an open state, allowing for unknown subclasses to extend it.

As an example, consider a Shape class that is declared as sealed, with two permitted subclasses - Circle and Square. In this case, Circle can be declared as final, while Square can be declared as non-sealed, allowing for unknown subclasses to further extend it.

It is important to note that a class can only have one modifier out of final, sealed, and non-sealed. It is not possible for a class to be sealed and final at the same time, as they serve opposite purposes.

Additionally, abstract classes can also be declared as sealed or non-sealed, and may have abstract members. Sealed classes may permit abstract subclasses as long as they are also sealed or non-sealed.

Lastly, a permitted subclass's accessibility does not have to match that of the sealed class. Subclasses can be less accessible, as long as they are still accessible to the sealed class. This may result in some users being unable to exhaustively switch over subclasses without a default clause in the future release when pattern matching is supported by switches.

To better understand the concept of sealed classes, let's take a look at some coding examples.

In the code snippet below, a sealed class Currency is defined.

sealed class Currency permits Dinar {
    //:sealed Check out the non-sealed class inheritance for legal recommendations
}

In order for a legal subsclass to be created, the class must be declared in the same module and be directly extend the Currency class. A sealed class cannot prevent its permitted subclasses from extending further in a restricted fashion or being open for extension by unknown subclasses. Hence Dinar must be in the same module.

Taking the code snippet further, the non-sealed class Dinar extends the sealed class Currency. The non-sealed class allows for further subclasses to be created and extended.

public non-sealed class Dinar extends Currency {
    // This class can be extended by any unknown subclass
}

Alternatively, if we want to restrict the subclasses that can extend Dinar, we can declare the class as sealed and specify which subclasses are permitted through the permits clause.

sealed class Dinar extends Currency permits JordanianDinar, KuwaitiDinar {
    // Only subclasses JordanianDinar and KuwaitiDinar are permitted 
}

The subclasses JordanianDinar and KuwaitiDinar must be declared in the same module as Dinar and must directly extend the sealed class Dinar. They can either be sealed, non-sealed, or even final, depending on the desired level of restriction.

Using sealed classes, we can create a hierarchy of related classes and have more control over which subclasses can be created and extended, providing better encapsulation and modularity in our code. It also helps enhance type safety as the compiler can warn us if we try to create an illegal subclass.

In conclusion, sealed classes offer a more organized and structured approach to class inheritance, allowing for more control and flexibility within a module. By imposing restrictions on subclasses and providing options for further extension, sealed classes provide a more deliberate and intentional class hierarchy.

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

Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn

Hot AI Tools

Undress AI Tool

Undress AI Tool

Undress images for free

Undresser.AI Undress

Undresser.AI Undress

AI-powered app for creating realistic nude photos

AI Clothes Remover

AI Clothes Remover

Online AI tool for removing clothes from photos.

Clothoff.io

Clothoff.io

AI clothes remover

Video Face Swap

Video Face Swap

Swap faces in any video effortlessly with our completely free AI face swap tool!

Hot Tools

Notepad++7.3.1

Notepad++7.3.1

Easy-to-use and free code editor

SublimeText3 Chinese version

SublimeText3 Chinese version

Chinese version, very easy to use

Zend Studio 13.0.1

Zend Studio 13.0.1

Powerful PHP integrated development environment

Dreamweaver CS6

Dreamweaver CS6

Visual web development tools

SublimeText3 Mac version

SublimeText3 Mac version

God-level code editing software (SublimeText3)

Comparing Java Frameworks: Spring Boot vs Quarkus vs Micronaut Comparing Java Frameworks: Spring Boot vs Quarkus vs Micronaut Aug 04, 2025 pm 12:48 PM

Pre-formanceTartuptimeMoryusage, Quarkusandmicronautleadduetocompile-Timeprocessingandgraalvsupport, Withquarkusoftenperforminglightbetterine ServerLess scenarios.2.Thyvelopecosyste,

What is a deadlock in Java and how can you prevent it? What is a deadlock in Java and how can you prevent it? Aug 23, 2025 pm 12:55 PM

AdeadlockinJavaoccurswhentwoormorethreadsareblockedforever,eachwaitingforaresourceheldbytheother,typicallyduetocircularwaitcausedbyinconsistentlockordering;thiscanbepreventedbybreakingoneofthefournecessaryconditions—mutualexclusion,holdandwait,nopree

How to join an array of strings in Java? How to join an array of strings in Java? Aug 04, 2025 pm 12:55 PM

Using String.join() (Java8) is the easiest recommended method for connecting string arrays, just specify the separator directly; 2. For old versions of Java or when more control is needed, you can use StringBuilder to manually traverse and splice; 3. StringJoiner is suitable for scenarios that require more flexible formats such as prefixes and suffixes; 4. Using Arrays.stream() combined with Collectors.joining() is suitable for filtering or converting the array before joining; To sum up, if Java8 and above is used, the String.join() method should be preferred in most cases, which is concise and easy to read, but for complex logic, it is recommended.

How to implement a simple TCP client in Java? How to implement a simple TCP client in Java? Aug 08, 2025 pm 03:56 PM

Importjava.ioandjava.net.SocketforI/Oandsocketcommunication.2.CreateaSocketobjecttoconnecttotheserverusinghostnameandport.3.UsePrintWritertosenddataviaoutputstreamandBufferedReadertoreadserverresponsesfrominputstream.4.Usetry-with-resourcestoautomati

How to compare two strings in Java? How to compare two strings in Java? Aug 04, 2025 am 11:03 AM

Use the .equals() method to compare string content, because == only compare object references rather than content; 1. Use .equals() to compare string values equally; 2. Use .equalsIgnoreCase() to compare case ignoring; 3. Use .compareTo() to compare strings in dictionary order, returning 0, negative or positive numbers; 4. Use .compareToIgnoreCase() to compare case ignoring; 5. Use Objects.equals() or safe call method to process null strings to avoid null pointer exceptions. In short, you should avoid using == for string content comparisons unless it is explicitly necessary to check whether the object is in phase.

How to send and receive messages over a WebSocket in Java How to send and receive messages over a WebSocket in Java Aug 16, 2025 am 10:36 AM

Create a WebSocket server endpoint to define the path using @ServerEndpoint, and handle connections, message reception, closing and errors through @OnOpen, @OnMessage, @OnClose and @OnError; 2. Ensure that javax.websocket-api dependencies are introduced during deployment and automatically registered by the container; 3. The Java client obtains WebSocketContainer through the ContainerProvider, calls connectToServer to connect to the server, and receives messages using @ClientEndpoint annotation class; 4. Use the Session getBasicRe

Correct posture for handling non-UTF-8 request encoding in Spring Boot application Correct posture for handling non-UTF-8 request encoding in Spring Boot application Aug 15, 2025 pm 12:30 PM

This article discusses the mechanism and common misunderstandings of Spring Boot applications for handling non-UTF-8 request encoding. The core lies in understanding the importance of the charset parameter in the HTTP Content-Type header, as well as the default character set processing flow of Spring Boot. By analyzing the garbled code caused by wrong testing methods, the article guides readers how to correctly simulate and test requests for different encodings, and explains that Spring Boot usually does not require complex configurations to achieve compatibility under the premise that the client correctly declares encoding.

Exploring Common Java Design Patterns with Examples Exploring Common Java Design Patterns with Examples Aug 17, 2025 am 11:54 AM

The Java design pattern is a reusable solution to common software design problems. 1. The Singleton mode ensures that there is only one instance of a class, which is suitable for database connection pooling or configuration management; 2. The Factory mode decouples object creation, and objects such as payment methods are generated through factory classes; 3. The Observer mode automatically notifies dependent objects, suitable for event-driven systems such as weather updates; 4. The dynamic switching algorithm of Strategy mode such as sorting strategies improves code flexibility. These patterns improve code maintainability and scalability but should avoid overuse.

See all articles