Sealed Class in Java

In programming, security and control flow are the two major concerns that must be considered while developing an application. There are various controlling features such as the use of final and protected keyword restricts the user to access variables and methods. Java 15 introduces a new preview feature that allows us to control the inheritance. In this section, we will discuss the preview feature, the concept of sealed class, and interface with proper examples.

Java Sealed Class

Java 15 introduced the concept of sealed classes. It is a preview feature. Java sealed classes and interfaces restrict that which classes and interfaces may extend or implement them.

In other words, we can say that the class that cannot be inherited but can be instantiated is known as the sealed class. It allows classes and interfaces to have more control over their permitted subtypes. It is useful both for general domain modeling and for building a more secure platform for libraries.

Note that the concept of sealed classes is a preview feature, not a permanent feature.

Preview Feature

A feature whose design, implementation, and specification are complete but not permanent. In future Java SE releases, the feature may exist in different forms or not at all.

Also, note that the code that has preview feature cannot be compile and run easily. It requires additional command-line options.

Using Preview Features

If we are using the preview feature in a Java program, we must explicitly enable the preview feature in the compiler and runtime systems. If we do not enable the preview feature, we get an error message "preview feature is disabled by default".

Use the following command to compile a Java program that has the preview feature:

Where n is the JDK version.

Suppose, Demo.java is a source file that has a preview feature and we want to compile and run it.

When we compile the above source file, we get the following warning message on the console.

Note: Demo.java uses preview language features.

Note: Recompile with -Xlint:preview for details

Use the following command to run a Java program that has the preview feature:

Note: It is not necessary that the code using a preview feature of an older version of Java SE compile or run on a newer release.

Uses of Sealed Class

Sealed classes work well with the following:

Java Reflection API
Java Records
Pattern Matching

Advantages of Sealed Class and Interface

It allows permission to the subclasses that can extend the sealed superclass.
It makes superclass broadly accessible but not broadly extensible.
It allows compilers to enforce the type system on the users of the class.
Developer of a superclass gets control over the subclasses. Hence, they can define methods in a more restricted way.

Defining a Sealed Class

The declaration of a sealed class is not much complicated. If we want to declare a class as sealed, add a sealed modifier to its declaration. After the class declaration and extends and implements clause, add permits clause. The clause denotes the classes that may extend the sealed class.

It presents the following modifiers and clauses:

sealed: It can only be extended by its permitted subclasses.
non-sealed: It can be extended by unknown subclasses; a sealed class cannot prevent its permitted subclasses from doing this.
permits: It allows the subclass to inherit and extend.
final: The permitted subclass must be final because it prevents further extensions.

For example, the following declaration of Subjects class specifies four permitted subclasses, English, Science, Mathematics, and Physics.

Subjects.java

//declaration of the sealed class
public sealed class Subjects
    permits English, Science, Mathematics, Physics {
}

Let's define the four permitted subclasses, English, Science, Mathematics, and Physics, in the same module or package in which the sealed class is defined.

English.java

public final class English extends Subjects {
    public double percentage;
}

Science.java

public non-sealed class Science extends Subjects {
   public String grade;
}   

Mathematics.java

public sealed class Mathematics extends Subjects permits AppliedMathematics {
    public double percentage;
    public String grade;
}

The Mathematics class has a further subclass, AppliedMathematics:

AppliedMathematics.java

public final class AppliedMathematics extends Mathematics {
    public int marks;
    public String grade; 
    public double percentage; 
}

Physics.java

public non-sealed class Physics extends Subjects {
   public int marks;
}   

On the other hand, we can also define permitted subclasses in the same file as the sealed class. In such a case, we can omit the permits clause:

//declaration of the sealed class
public sealed class Subjects
    permits English, Science, Mathematics, Physics {
}
public final class English extends Subjects {
    public double percentage;
}
public non-sealed class Science extends Subjects {
   public String grade;
}   
public sealed class Mathematics extends Subjects permits AppliedMathematics {
    public double percentage;
    public String grade;
}
public final class AppliedMathematics extends Mathematics {
    public int marks;
    public String grade; 
    public double percentage; 
}
public non-sealed class Physics extends Subjects {
   public int marks;
}   

Constraints on Permitted Subclass

If a class is defined as sealed, it enforces the following three limitations on its permitted subclass.

1. All the permitted subclasses must belong to the same module or package as the sealed class. For example:

Suppose, we have the same unnamed module and the following packages:

  -package com.javatpoint.p1
     -MainClass.java
  -package com.javatpoint.p2
     -ClassA.java

   -root
      -ClassA.java
      -package com.javatpoint.p1
         -MainClass.java

We get an error "The class is not allowed to extend the sealed class from another package or module."

2. Every permitted subclass must explicitly extend the sealed class.

3. Every permitted subclass must define a modifier: final, sealed, or non-sealed.

Sealed Interface

Like the sealed classes, we can also define a sealed interface just by adding a sealed modifier before the interface name. After that use extends keyword (if require), and then define permits clause.

public sealed interface Fruits permits Mango, Pineapple
{ 
int getCost(); 
default int getQuantity() 
{ 
return 5; 
} 
}

The interface only permits Mango and Pineapple to implement it.

Let's understand the concept of Sealed class through a Java program.

Note: Before exacting the following program, ensure that Java 15 or a later version is installed in your system. Otherwise, you will get errors.

Example of Sealed Class

SealedClassExample.java

public class SealedClassExample 
{
public static void main(String args[]) 
{
//creating an instance of GrandFather class
Person grandfather = new GrandFather(87, "Albert");
grandfather.name = "Albert";
System.out.println("The age of grandfather is: "+getAge(grandfather));
}
// getting the age of the Person
public static int getAge(Person person) 
{
//if the person is an instance of the Father class, returns the age of the father
if (person instanceof Father) 
{
//cast the person class to Father class and get the age
return ((Father) person).getFatherAge();
} 
//if the person is an instance of the GrandFather class, returns grandfather age
else if (person instanceof GrandFather) 
{
return ((GrandFather) person).getGrandFatherAge();
}
//returns nothing if does not match with any of the above conditions
return -1;
}
}
//the class person extends only Father and GrandFather class
abstract sealed class Person permits Father, GrandFather
{
String name;
String getName() 
{
return name;
}
}

final class Father extends Person 
{
String name;
int age;
//constructor of the Father class
Father(int age, String name)
{
this.age = age;
this.name = name;
}
int getFatherAge() 
{
return age;
}
}
//non-sealed class extends unknown subclass (Person)
non-sealed class GrandFather extends Person 
{
int age;
GrandFather(int age, String name)
{
this.age = age;
this.name = name;
}
int getGrandFatherAge() 
{
return age;
}
}

Output: