If you have experience with C#, then the sealed keyword might be confusing to you. C# uses the sealed keyword to prevent inheritance from a class, the same way Java uses final when declaring a class. Sealed classes in Kotlin are used to define restricted class hierarchies.

Sealed classes are similar to enum classes; you use them to define a fixed set of options. But unlike enum classes, where each constant is a single instance, sealed classes can have multiple instances for each option.

This restricted class hierarchy can be really useful when used with when expressions.

Here's an example of a sealed class hierarchy used with a when statement:

sealed class SuperHero

class Hulk: SuperHero() {
    fun smashOpponent() {

    }
}
class SuperMan : SuperHero() {
    fun flyToKrypton() {

    }
}
class SpiderMan : SuperHero() {
    fun useSpiderSense() {

    }
}
fun actOnHero(hero: SuperHero) {
    when (hero) {
        is Hulk -> {
            hero.smashOpponent()
        }
        is SuperMan -> {
            hero.flyToKrypton()
        }
        is SpiderMan -> {
            hero.useSpiderSense()
        }
    }
}

You define only one sealed class, the one that acts as the base class for your class hierarchy. All other classes that inherit from the sealed classes can be normal classes, data classes, or objects. Inheriting classes have to be declared in the same file as the sealed class.

A sealed class acts as an abstract class and the compiler will not allow you to create an instance of it. Also, it cannot have non-private constructors, because its constructor is private by default.