Kotlin Afgesloten Klasse

In deze tutorial zullen we ons verdiepen in Kotlin Sealed Class. Wat zijn ze? Waarvoor worden ze gebruikt? We zullen al deze zaken hieronder bespreken.

Kotlin Sealed Class

In eenvoudige bewoordingen zijn sealed classes zoals de naam al aangeeft, afgesloten of gesloten, waardoor ze beperkt zijn. Sealed classes worden gebruikt voor het voorstellen van beperkte klassenhiërarchieën waarbij het object of de waarde alleen waarde kan hebben tussen een van de typen, waardoor uw typenhiërarchieën worden vastgelegd. Sealed classes worden vaak gebruikt in gevallen waarin u weet dat een gegeven waarde slechts onder een bepaalde reeks opties kan vallen.

Implementatie van Kotlin Sealed Classes

Sealed classes in Kotlin worden geïmplementeerd op de volgende manier.

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

Om een sealed class aan te geven, moet je de modifier sealed toevoegen. Een sealed class kan niet geïnstantieerd worden en is daarom impliciet abstract. Het volgende zal NIET werken.

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

Constructors van een sealed class zijn standaard privé. Alle subklassen van een sealed class moeten binnen hetzelfde bestand worden verklaard. Sealed classes zijn belangrijk om typeveiligheid te waarborgen door de reeks typen alleen op compileertijd te beperken.

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

Het maken van een afgesloten klasse met constructeurs.

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

Het toevoegen van Data Class en Object in een afgesloten 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()

}

Verschil tussen enum en afgesloten klassen

In Kotlin kunnen Afgesloten Klassen worden beschouwd als Enum-klassen met extra mogelijkheden. Afgesloten klassen stellen ons in staat om instanties te maken met verschillende typen, in tegenstelling tot Enums die ons beperken tot het gebruik van hetzelfde type voor alle enum-constanten. Het volgende is niet mogelijk in Enum-klassen.

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

Enum-klassen staan slechts één type toe voor alle constanten. Hier komen afgesloten klassen te hulp door meerdere instanties toe te staan.

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

Hoe kun je deze functie van Afgesloten klassen gebruiken in jouw projecten? In een nieuwsfeed-applicatie kun je bijvoorbeeld drie verschillende klassentypen maken voor statussen, afbeeldingen en videoberichten zoals hieronder getoond.

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

Dit is niet mogelijk met Enum-klassen.

Afgesloten klassen en when

Afgesloten klassen worden vaak gebruikt met `when`-statements omdat elk van de subklassen en hun typen fungeren als een geval. Bovendien weten we dat de Afgesloten klasse de typen beperkt. Daarom kan het `else`-deel van de `when`-verklaring eenvoudig worden verwijderd. Het volgende voorbeeld demonstreert hetzelfde.

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

Laten we de `eval`-functie uitvoeren in onze `main`-functie zoals hieronder getoond.

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) //compile-time error.

}

//Het volgende wordt afgedrukt op de console:
//Cirkeloppervlak is 63.585
//Vierkantsoppervlak is 16
//Rechthoekoppervlak is 20

Noot: De `is`-modifier controleert of de klasse van het volgende type is. De `is`-modifier is alleen vereist voor klassen. Niet bij Kotlin-objecten zoals hieronder getoond:

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

Dit markeert het einde van de Kotlin-afgesloten klasse tutorial. Referenties: Kotlin-documenten