Kotlin Sealed Class

Ccentron Redaktion · March 2024 ·4 min read ·Python, Tutorial

In this tutorial, we’ll be looking into Kotlin Sealed Class. What are they? What’s their use? We’ll be addressing all of these things below.

In layman terms, as the name suggests, sealed classes are sealed or closed, hence making them restricted. Sealed classes are used for representing restricted class hierarchies wherein the object or the value can have value only among one of the types, thus fixing your type hierarchies. Sealed classes are commonly used in cases, where you know what a given value to be only among a given set of options.

Implementing Kotlin Sealed Classes

Sealed classes in Kotlin are implemented in the following manner.

Code

sealed class A{
    class B : A()
    class C : A()
}

To specify a sealed class, you need to add the modifier sealed. A sealed class cannot be instantiated. Hence, are implicitly abstract. The following WON’T work.

Code

fun main(args: Array<String>) 
{
    var a = A() //compiler error. Class A cannot be instantiated.
}

Constructors of a sealed class are private by default. All subclasses of a sealed class must be declared within the same file. Sealed classes are important in ensuring type safety by restricting the set of types at compile-time only.

Code

sealed class A{
    class B : A() 
    {
        class E : A() //this works.
    }
    class C : A()

    init {
        println("sealed class A")
    }

}

class D : A() //this works
{
class F: A() //This won't work. Since sealed class is defined in another scope.
}

Creating a sealed class with constructors.

Code

sealed class A(var name: String){
    class B : A("B")
    class C : A("C")
}

class D : A("D")
fun main(args: Array<String>) {
    
    var b = A.B()
    var d = D()
}

Adding Data Class and Object in a sealed class.

Code

fun main(args: Array<String>) {

    val e = A.E("Anupam")
    println(e) //prints E(name=Anupam)

    var d = A.D
    d.name() //prints Object D
}


sealed class A{
    class B : A()
    class C : A()
    object D : A()
    {
         fun name()
         {
             println("Object D")
         }
    }
    data class E(var name: String) : A()

}

Matching infrastructure at centron

Scripts and services eventually need an environment that keeps running: ccloud³ VMs from €3.12 per month, billed by the hour. Rent a cloud server →

Difference between enum and sealed classes

In Kotlin, Sealed Classes can be termed as Enum classes on steroids. Sealed classes allow us to create instances with different types, unlike Enums which restrict us to use the same type for all enum constants. The following isn’t possible in Enum classes.

Code

enum class Months(string: String){
January("Jan"), February(2),
}

Enum classes allow only a single type for all constants. Here’s where sealed classes come to our rescue by allowing multiple instances.

Code

sealed class Months {
    class January(var shortHand: String) : Months()
    class February(var number: Int) : Months()
    class March(var shortHand: String, var number: Int) : Months()
}

How can you use this feature of Sealed classes in your Projects?

In a newsfeed like application, you can create three different class types for Status, Image, Video posts as shown below.

Code

sealed class Post
{
    class Status(var text: String) : Post()
    class Image(var url: String, var caption: String) : Post()
    class Video(var url: String, var timeDuration: Int, var encoding: String): Post()
}

This isn’t possible with Enum classes.

Sealed classes and when

Sealed classes are commonly used with when statements since each of the subclasses and their types act as a case. Moreover, we know that the Sealed class limits the types. Hence, the else part of the when statement can be easily removed. Following example demonstrates the same.

Code

sealed class Shape{
    class Circle(var radius: Float): Shape()
    class Square(var length: Int): Shape()
    class Rectangle(var length: Int, var breadth: Int): Shape()
}

fun eval(e: Shape) =
        when (e) {
            is Shape.Circle -> println("Circle area is ${3.14*e.radius*e.radius}")
            is Shape.Square -> println("Square area is ${e.length*e.length}")
            is Shape.Rectangle -> println("Rectangle area is ${e.length*e.breadth}")
        }

Let’s execute the eval function in our main function as shown below.

Code

fun main(args: Array<String>) {

    var circle = Shape.Circle(4.5f)
    var square = Shape.Square(4)
    var rectangle = Shape.Rectangle(4,5)

    eval(circle)
    eval(square)
    eval(rectangle)
    //eval(x) //compile-time error.

}

//Following is printed on the console:
//Circle area is 63.585
//Square area is 16
//Rectangle area is 20

Note: The is modifier checks if the class is of the following type. is modifier is required only for classes. Not with Kotlin objects as shown below:

Code

sealed class Shape{
    class Circle(var radius: Float): Shape()
    class Square(var length: Int): Shape()
    object Rectangle: Shape()
    {
        var length: Int = 0
        var breadth : Int = 0
    }
}

fun eval(e: Shape) =
        when (e) {
            is Shape.Circle -> println("Circle area is ${3.14*e.radius*e.radius}")
            is Shape.Square -> println("Square area is ${e.length*e.length}")
            Shape.Rectangle -> println("Rectangle area is ${Shape.Rectangle.length*Shape.Rectangle.breadth}")
        }

This brings an end to Kotlin sealed class tutorial.

Jetzt 200 € Guthaben sichern

Testen Sie Ihr Setup auf ccloud³

Registrieren Sie sich in der ccloud³ und erhalten Sie 200 € Startguthaben für Ihr Projekt – z. B. für eine PostgreSQL-VM mit automatischen Backups.

Jetzt loslegen

Kotlin Sealed Class - Tutorial