Clase Sellada de Kotlin

En este tutorial, estaremos explorando la Clase Sellada de Kotlin. ¿Qué son? ¿Cuál es su uso? Abordaremos todas estas cuestiones a continuación.

Clase Sellada de Kotlin

En términos sencillos, como su nombre sugiere, las clases selladas están selladas o cerradas, lo que las hace restringidas. Las clases selladas se utilizan para representar jerarquías de clases restringidas en las que el objeto o el valor solo puede tener valor entre uno de los tipos, fijando así tus jerarquías de tipos. Las clases selladas se utilizan comúnmente en casos en los que sabes que un valor dado debe estar solo entre un conjunto dado de opciones.

Implementación de Clases Selladas en Kotlin

Las clases selladas en Kotlin se implementan de la siguiente manera.

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

Para especificar una clase sellada, debes agregar el modificador sealed. Una clase sellada no se puede instanciar. Por lo tanto, son implícitamente abstractas. Lo siguiente NO funcionará.

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

Los constructores de una clase sellada son privados por defecto. Todas las subclases de una clase sellada deben declararse dentro del mismo archivo. Las clases selladas son importantes para garantizar la seguridad de tipo al restringir el conjunto de tipos solo en tiempo de compilación.

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.
}

Creando una clase sellada con constructores.

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()
}

Agregando la Clase de Datos y Objeto en una clase sellada.

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()

}

Diferencia entre enumeraciones y clases selladas

En Kotlin, las clases selladas pueden considerarse como clases de enumeración con esteroides. Las clases selladas nos permiten crear instancias con diferentes tipos, a diferencia de las enumeraciones que nos restringen a usar el mismo tipo para todas las constantes de la enumeración. Lo siguiente no es posible en clases de enumeración.

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

Las clases de enumeración permiten solo un tipo único para todas las constantes. Aquí es donde las clases selladas vienen a nuestro rescate al permitir múltiples instancias.

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

¿Cómo puedes usar esta característica de las clases selladas en tus proyectos? En una aplicación de noticias, puedes crear tres tipos de clase diferentes para publicaciones de Estado, Imagen y Video como se muestra a continuación.

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()
}

Esto no es posible con clases de enumeración.

Clases selladas y when

Las clases selladas se utilizan comúnmente con declaraciones when ya que cada una de las subclases y sus tipos actúan como un caso. Además, sabemos que la clase sellada limita los tipos. Por lo tanto, la parte else de la declaración when se puede eliminar fácilmente. El siguiente ejemplo demuestra lo mismo.

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("Rectagle area is ${e.length*e.breadth}")
        }

Ejecutemos la función eval en nuestra función main como se muestra a continuación.

fun main(args: Array) {

    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) //error en tiempo de compilación.

}

//Lo siguiente se imprime en la consola:
//El área del círculo es 63.585
//El área del cuadrado es 16
//El área del rectángulo es 20

Nota: El modificador is verifica si la clase es del tipo siguiente. El modificador is solo es necesario para las clases. No con objetos Kotlin como se muestra a continuación:

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}")
        }

Esto marca el final del tutorial de clases selladas en Kotlin. Referencias: Documentos de Kotlin