Java sealed Keyword

The sealed keyword in Java is used to restrict which classes or interfaces can extend or implement a given class or interface. This feature, introduced in Java 17, allows developers to define a more controlled and predictable class hierarchy. A sealed class or interface specifies a list of permitted subclasses or implementors, providing more fine-grained control over inheritance.

Table of Contents

1. Introduction
2. sealed Keyword Syntax
3. Understanding sealed
4. Examples
   • Sealed Class
   • Sealed Interface
   • Permitting Classes
5. Real-World Use Case
6. Conclusion

Introduction

In Java, the sealed keyword allows you to declare a class or interface as sealed, meaning only specified subclasses or implementors can extend or implement it. This helps in creating a more controlled inheritance hierarchy and can be useful for maintaining security and predictability in your application’s design.

sealed Keyword Syntax

The syntax for declaring a sealed class or interface is as follows:

public sealed class ClassName permits Subclass1, Subclass2 { // class body } public sealed interface InterfaceName permits Implementor1, Implementor2 { // interface body } 

Example:

public sealed class Shape permits Circle, Rectangle, Square { // class body } 

Understanding sealed

Key Points:

• Controlled Inheritance: The sealed keyword restricts which classes can extend or implement a class or interface.
• Permits Clause: The permits clause specifies the allowed subclasses or implementors.
• Subclasses: The subclasses must either be final, sealed, or non-sealed.

Types of Subclasses:

1. final: No further subclassing is allowed.
2. sealed: Further subclassing is restricted to specific classes.
3. non-sealed: The class can be subclassed without restrictions.

Examples

Sealed Class

A sealed class with permitted subclasses.

Example

// File: Shape.java public sealed class Shape permits Circle, Rectangle, Square { // common properties and methods } // File: Circle.java public final class Circle extends Shape { // properties and methods specific to Circle } // File: Rectangle.java public sealed class Rectangle extends Shape permits Square { // properties and methods specific to Rectangle } // File: Square.java public final class Square extends Rectangle { // properties and methods specific to Square } 

Sealed Interface

A sealed interface with permitted implementors.

Example

// File: Operation.java public sealed interface Operation permits Addition, Subtraction { int apply(int a, int b); } // File: Addition.java public final class Addition implements Operation { @Override public int apply(int a, int b) { return a + b; } } // File: Subtraction.java public final class Subtraction implements Operation { @Override public int apply(int a, int b) { return a - b; } } 

Permitting Classes

A sealed class that permits only specified classes to extend it.

Example

// File: Animal.java public sealed class Animal permits Dog, Cat { // common properties and methods } // File: Dog.java public final class Dog extends Animal { // properties and methods specific to Dog } // File: Cat.java public final class Cat extends Animal { // properties and methods specific to Cat } 

Real-World Use Case

Financial Transactions

In a financial application, you might want to control the types of transactions that can occur, such as deposits and withdrawals, ensuring no other transaction types are inadvertently created.

Example

// File: Transaction.java public sealed class Transaction permits Deposit, Withdrawal { // common properties and methods } // File: Deposit.java public final class Deposit extends Transaction { // properties and methods specific to Deposit } // File: Withdrawal.java public final class Withdrawal extends Transaction { // properties and methods specific to Withdrawal } 

Conclusion

The sealed keyword in Java provides a powerful mechanism for controlling inheritance and implementation hierarchies. By specifying which classes or interfaces can extend or implement a sealed class or interface, you can ensure a more predictable and secure design. Understanding and using the sealed keyword effectively is crucial for developing robust and maintainable Java applications.