Kotlin Versiegelte Klasse

In diesem Tutorial werden wir uns die Kotlin Sealed Class ansehen. Was sind sie? Wofür werden sie verwendet? Wir werden all diese Dinge unten behandeln.

Kotlin Sealed Class

Im Allgemeinen sind versiegelte Klassen, wie der Name schon sagt, versiegelt oder geschlossen und daher eingeschränkt. Versiegelte Klassen werden verwendet, um eingeschränkte Klassenhierarchien darzustellen, bei denen das Objekt oder der Wert nur einen der Typen haben kann und somit Ihre Typenhierarchien festlegt. Versiegelte Klassen werden häufig in Fällen verwendet, in denen Sie wissen, dass ein bestimmter Wert nur unter einer bestimmten Option liegt.

Implementieren von Kotlin versiegelten Klassen

Versiegelte Klassen in Kotlin werden wie folgt implementiert.

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

Um eine versiegelte Klasse anzugeben, müssen Sie den Modifier sealed hinzufügen. Eine versiegelte Klasse kann nicht instanziiert werden. Daher sind sie implizit abstrakt. Das Folgende funktioniert NICHT.

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

Die Konstruktoren einer versiegelten Klasse sind standardmäßig privat. Alle Unterklassen einer versiegelten Klasse müssen in derselben Datei deklariert werden. Versiegelte Klassen sind wichtig, um Typsicherheit zu gewährleisten, indem sie die Menge der Typen nur zur Compile-Zeit einschränken.

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

Erstellen einer versiegelten Klasse mit Konstruktoren.

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

Hinzufügen von Datenklasse und Objekt in einer versiegelten Klasse.

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

}

Unterschied zwischen Aufzählungen und versiegelten Klassen

In Kotlin können versiegelte Klassen als Aufzählungsklassen auf Steroiden bezeichnet werden. Versiegelte Klassen ermöglichen es uns, Instanzen mit unterschiedlichen Typen zu erstellen, im Gegensatz zu Aufzählungen, die uns darauf beschränken, denselben Typ für alle Aufzählungskonstanten zu verwenden. Das Folgende ist in Aufzählungsklassen nicht möglich.

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

Aufzählungsklassen erlauben nur einen einzigen Typ für alle Konstanten. Hier kommen versiegelte Klassen zu unserer Rettung, indem sie mehrere Instanzen zulassen.

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

Wie können Sie diese Funktion von versiegelten Klassen in Ihren Projekten verwenden? In einer Anwendung wie einem Newsfeed können Sie drei verschiedene Klassentypen für Status-, Bild- und Videobeiträge erstellen, wie unten gezeigt.

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

Dies ist mit Aufzählungsklassen nicht möglich.

Versiegelte Klassen und wenn

Versiegelte Klassen werden häufig mit when-Anweisungen verwendet, da jede der Unterklassen und ihre Typen wie ein Fall fungieren. Außerdem wissen wir, dass die versiegelte Klasse die Typen einschränkt. Daher kann der else-Teil der when-Anweisung leicht entfernt werden. Das folgende Beispiel demonstriert dasselbe.

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

Lassen Sie uns die eval-Funktion in unserer main-Funktion wie folgt ausführen.

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) //Kompilierfehler.

}

//Folgendes wird auf der Konsole gedruckt:
//Kreisfläche beträgt 63.585
//Quadratfläche beträgt 16
//Rechteckfläche beträgt 20

Hinweis: Der is-Modifizierer überprüft, ob die Klasse vom folgenden Typ ist. Der is-Modifizierer ist nur für Klassen erforderlich. Nicht bei Kotlin-Objekten, wie unten gezeigt:

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

Damit endet das Kotlin-versiegelte-Klassen-Tutorial. Referenzen: Kotlin-Dokumentation