Quelle est la différence entre les classes scellées…

La principale différence entre les classes sealed et abstraites est que les classes sealed limitent la hiérarchie d'héritage à un seul fichier ou module (pour Kotlin 1.5+). Les héritiers d'une classe sealed doivent être déclarés dans le même fichier que la classe sealed elle-même, ce qui garantit une vérification exhaustive lors de l'utilisation des expressions when.

Différences :

Héritage :
- Les classes abstraites peuvent être héritées n'importe où dans le projet.
- Les classes sealed ne peuvent être héritées qu'au sein du même fichier (avant Kotlin 1.5) ou dans le même module (avec Kotlin 1.5+).
Utilisation avec when :
- Lorsqu'on utilise when avec un type sealed, le compilateur peut vérifier que tous les sous-types possibles ont été pris en compte, rendant when exhaustif et évitant d'avoir à spécifier explicitement une branche else si tous les sous-types sont traités.
- Avec des classes abstraites, le compilateur ne peut pas garantir l'exhaustivité, donc un else est souvent nécessaire.
Création d'instances :
- Ni les classes abstraites ni les classes sealed ne peuvent être instanciées directement.
Membres :
- Les classes abstraites et sealed peuvent avoir des membres abstraits et non abstraits.

Exemple de classe sealed :

sealed class Result<out T> {
    data class Success<out T>(val data: T) : Result<T>()
    data class Error(val message: String) : Result<Nothing>()
}

fun processResult(result: Result<Int>) {
    when (result) {
        is Result.Success -> {
            // Traitement du succès
            println("Succès : ${result.data}")
        }
        is Result.Error -> {
            // Traitement de l'erreur
            println("Erreur : ${result.message}")
        }
        // Pas besoin d'else si tous les sous-types sont traités
    }
}

Exemple de classe abstraite :

abstract class Shape {
    abstract fun area(): Double
}

class Circle(val radius: Double) : Shape() {
    override fun area(): Double = Math.PI * radius * radius
}

class Rectangle(val width: Double, val height: Double) : Shape() {
    override fun area(): Double = width * height
}

fun calculateArea(shape: Shape): Double {
    return shape.area()
}

Quand l'utiliser :

Classes sealed : Idéales pour représenter un ensemble limité d'états ou de types possibles, lorsque vous avez besoin d'une vérification exhaustive dans les expressions when. Souvent utilisées pour modéliser les résultats d'opérations (succès/erreur), les états de l'interface utilisateur, les événements.
Classes abstraites : Conviennent pour définir une fonctionnalité générale et un contrat pour un groupe de classes liées, qui peuvent être héritées n'importe où dans le projet.

En résumé, les classes sealed offrent un contrôle plus strict sur la hiérarchie d'héritage et améliorent la sécurité et la lisibilité du code lors du traitement d'un ensemble limité de sous-types.

Quelle est la différence entre les classes scellées et les classes abstraites en Kotlin?