Classe sigillata Kotlin

In questo tutorial, esamineremo la classe sigillata di Kotlin. Cosa sono? A cosa servono? Affronteremo tutte queste cose di seguito.

Classe Sigillata di Kotlin

In termini semplici, come suggerisce il nome, le classi sigillate sono sigillate o chiuse, rendendole quindi restrittive. Le classi sigillate vengono utilizzate per rappresentare gerarchie di classi restrittive in cui l’oggetto o il valore può avere un valore solo tra uno dei tipi, fissando così le gerarchie dei tipi. Le classi sigillate sono comunemente utilizzate nei casi in cui si sa che un dato valore può essere solo tra un dato insieme di opzioni.

Implementazione delle Classi Sigillate di Kotlin

Le classi sigillate in Kotlin vengono implementate nel seguente modo.

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

Per specificare una classe sigillata, è necessario aggiungere il modificatore sealed. Una classe sigillata non può essere istanziata. Pertanto, sono implicitamente astratte. Il seguente NON funzionerà.

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

I costruttori di una classe sigillata sono privati per impostazione predefinita. Tutte le sottoclassi di una classe sigillata devono essere dichiarate nello stesso file. Le classi sigillate sono importanti per garantire la sicurezza dei tipi limitando l’insieme di tipi solo durante la compilazione.

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

Creare una classe sigillata con costruttori.

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

Aggiungere la classe Data e l’Oggetto in una classe sigillata.

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

}

Differenza tra enum e classi sigillate

Nel linguaggio Kotlin, le classi sigillate possono essere definite come classi Enum potenziate. Le classi sigillate ci consentono di creare istanze con tipi diversi, a differenza degli Enum che ci limitano a utilizzare lo stesso tipo per tutte le costanti enum. Quanto segue non è possibile nelle classi Enum.

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

Le classi Enum consentono solo un singolo tipo per tutte le costanti. Qui entrano in gioco le classi sigillate, permettendoci di avere molteplici istanze.

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

Come puoi utilizzare questa caratteristica delle classi sigillate nei tuoi progetti? In un’applicazione tipo feed di notizie, puoi creare tre diversi tipi di classi per gli stati, le immagini e i video come mostrato di seguito.

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

Questo non è possibile con le classi Enum.

Classi sigillate e when

Le classi sigillate sono comunemente utilizzate con le istruzioni when poiché ciascuna delle sottoclassi e i relativi tipi agiscono come un caso. Inoltre, sappiamo che la classe sigillata limita i tipi. Pertanto, la parte else dell’istruzione when può essere facilmente rimossa. L’esempio seguente dimostra lo stesso.

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

Eseguiamo la funzione eval nella nostra funzione main come mostrato di seguito.

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) //errore in fase di compilazione.

}

//Quanto segue viene stampato sulla console:
//L'area del cerchio è 63.585
//L'area del quadrato è 16
//L'area del rettangolo è 20

Nota: Il modificatore is verifica se la classe è del tipo seguente. Il modificatore is è richiesto solo per le classi. Non con gli oggetti Kotlin come mostrato di seguito:

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

Questo conclude il tutorial sulle classi sigillate di Kotlin. Riferimenti: Documenti Kotlin