Clases selladas de Kotlin

Kotlin proporciona un nuevo tipo de clase importante que no está presente en Java. Estas se conocen como clases selladas . Como sugiere la palabra sellada, las clases selladas se ajustan a jerarquías de clases limitadas o restringidas . Una clase sellada define un conjunto de subclases dentro de ella. Se utiliza cuando se sabe de antemano que un tipo se ajustará a uno de los tipos de subclases. Las clases selladas garantizan la seguridad de los tipos al restringir los tipos que deben coincidir en tiempo de compilación en lugar de en tiempo de ejecución.

Sintaxis: Declaración de clase sellada

sealed class Demo

Para definir una clase sellada, simplemente precede el modificador de clase con la palabra clave sellada. Las clases selladas también tienen otra característica distinta, sus constructores están protegidos por defecto. Una clase sellada es implícitamente abstracta y, por lo tanto, no se puede instanciar.

sealed class Demo
fun main(args: Array)
{
    var d = Demo()     //compiler error  
}

Ejemplo: programa Kotlin de clase sellada  

sealed class Demo {
    class A:Demo(){
        fun display(){
            println("Subclass A of Sealed class Demo ")
        }
    }
    class B:Demo(){
        fun display(){
            println("Subclass B of sealed class Demo")
        }
    }
}
 
fun main(args: Array<String>){
    val obj =Demo.B()
    obj.display()
    val obj1=Demo.A()
    obj1.display()
}

Producción:

Subclass B of sealed class Demo
Subclass A of sealed class Demo

Nota: Todas las subclases de la clase sellada deben estar definidas dentro del mismo archivo Kotlin . Sin embargo, no es necesario definirlos dentro de la clase sellada, se pueden definir en cualquier ámbito donde la clase sellada sea visible.

Ejemplo:

// A sealed class with a single subclass defined inside
sealed class ABC {
 class X: ABC(){...}
}

// Another subclass of the sealed class defined
class Y: ABC() {
  class Z: ABC()   // This will cause an error. Sealed class is not visible here
}

Recuerde Clase sellada con cuando una clase sellada se usa más comúnmente con una cláusula when , ya que los tipos a los que puede ajustarse una referencia de clase sellada son limitados. Esto elimina por completo el uso de la cláusula  else .

Ejemplo: demostrar clases selladas con una cláusula when

// A sealed class with a string property
sealed class Fruit
(val x : String)
{
    // Two subclasses of sealed class defined within
    class Apple : Fruit("
    Apple& quot;)
    class Mango : Fruit("
    Mango& quot;)
}
 
// A subclass defined outside the sealed class
class Pomegranate: Fruit("
Pomegranate& quot;)
 
// A function to take in an object of type Fruit
// And to display an appropriate message depending on the type of Fruit
fun display(fruit: Fruit)
{
    when(fruit)
    {
        is Fruit.Apple - > println("${fruit.x} is good for iron")
        is Fruit.Mango ->
        println(" ${ fruit.x } is delicious & quot;)
                is Pomegranate
            - > println("${fruit.x} is good for vitamin d")
    }
}
fun main()
{
    // Objects of different subclasses created
    val obj = Fruit.Apple() val obj1
        = Fruit.Mango() val obj2 = Pomegranate()
 
        // Function called with different objects
        display(obj) display(obj1) display(obj2)
}

Producción:

Apple is good for iron
Mango is delicious
Pomegranate is good for vitamin d