Classe scellée Kotlin

Dans ce tutoriel, nous allons nous pencher sur la classe scellée Kotlin. Qu’est-ce que c’est ? À quoi servent-elles ? Nous aborderons toutes ces questions ci-dessous.

Classe scellée Kotlin

En termes simples, comme son nom l’indique, les classes scellées sont scellées ou fermées, ce qui les rend restreintes. Les classes scellées sont utilisées pour représenter des hiérarchies de classe restreintes où l’objet ou la valeur ne peut avoir une valeur que parmi l’un des types, fixant ainsi vos hiérarchies de types. Les classes scellées sont couramment utilisées dans les cas où vous savez qu’une valeur donnée ne peut être que parmi un ensemble donné d’options.

Mise en œuvre des classes scellées Kotlin

Les classes scellées en Kotlin sont implémentées de la manière suivante.

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

Pour spécifier une classe scellée, vous devez ajouter le modificateur sealed. Une classe scellée ne peut pas être instanciée. Elle est donc implicitement abstraite. Ce qui suit NE fonctionnera PAS.

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

Les constructeurs d’une classe scellée sont privés par défaut. Toutes les sous-classes d’une classe scellée doivent être déclarées dans le même fichier. Les classes scellées sont importantes pour garantir la sécurité des types en restreignant l’ensemble des types uniquement au moment de la compilation.

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

Création d’une classe scellée avec des 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()
}

Ajout d’une classe de données et d’un objet dans une classe scellée.

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

}

Différence entre les énumérations et les classes scellées

En Kotlin, les classes scellées peuvent être considérées comme des classes Enum améliorées. Les classes scellées nous permettent de créer des instances avec différents types, contrairement aux énumérations qui nous obligent à utiliser le même type pour toutes les constantes d’énumération. Ce qui n’est pas possible avec les classes Enum.

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

Les classes Enum n’autorisent qu’un seul type pour toutes les constantes. C’est là que les classes scellées interviennent en nous permettant d’avoir plusieurs instances.

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

Comment pouvez-vous utiliser cette fonctionnalité des classes scellées dans vos projets ? Dans une application de flux d’actualités, vous pouvez créer trois types de classes différents pour les publications de statut, d’image et de vidéo, comme illustré ci-dessous.

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

Ce qui n’est pas possible avec les classes Enum.

Classes scellées et l’instruction when

Les classes scellées sont couramment utilisées avec les instructions when puisque chacune des sous-classes et leurs types agissent comme un cas. De plus, nous savons que la classe scellée limite les types. Par conséquent, la partie else de l’instruction when peut être facilement supprimée. L’exemple suivant démontre la même chose.

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

Exécutons la fonction eval dans notre fonction main comme illustré ci-dessous.

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) //erreur de compilation.

}

//Ce qui suit est imprimé sur la console:
//L'aire du cercle est de 63,585
//L'aire du carré est de 16
//L'aire du rectangle est de 20

Note: Le modificateur is vérifie si la classe est du type suivant. Le modificateur is est nécessaire uniquement pour les classes. Pas avec les objets Kotlin comme illustré ci-dessous:

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

Cela met fin au tutoriel sur les classes scellées de Kotlin. Références: Docs Kotlin