Vocabulaire Kotlin - Classes scellées

Souvent, nous devons représenter un ensemble limité de possibilités; une requête Web réussit ou échoue, a Userne peut être qu'un utilisateur professionnel ou un utilisateur standard.

Pour modéliser cela, nous pourrions utiliser un enum, mais cela comporte un certain nombre de limitations. Les classes Enum n'autorisent qu'une seule instance de chaque valeur et ne peuvent pas encoder plus d'informations sur chaque type, par exemple un Errorcas ayant une Exceptionpropriété associée .

Vous pouvez utiliser une classe abstraite et un certain nombre d'extensions, mais cela perd l'avantage de l'ensemble restreint de types apporté par les enums. Les classes scellées offrent le meilleur des deux mondes: la liberté de représentation des classes abstraites et l'ensemble restreint de types d'énumérations. Lisez la suite pour en savoir plus sur les classes scellées ou, si vous préférez une vidéo, regardez-la ici:

Les bases des classes scellées

Comme les classes abstraites, les classes scellées vous permettent de représenter des hiérarchies. Les classes enfants peuvent être n'importe quel type de classe: une classe de données, un objet , une classe régulière ou même une autre classe scellée. Contrairement aux classes abstraites, vous devez définir ces hiérarchies dans le même fichier ou en tant que classes imbriquées.

// Result.kt
sealed class Result<out T : Any> {
    data class Success<out T : Any>(val data: T) : Result<T>()
    data class Error(val exception: Exception) : Result<Nothing>()
}

Cannot access ‘<init>’: it is private in Result

Souvent, nous voulons gérer tous les types possibles:

when(result) {
    is Result.Success -> { }
    is Result.Error -> { }
}

sealed class Result<out T : Any> {
    data class Success<out T : Any>(val data: T) : Result<T>()
    data class Error(val exception: Exception) : Result<Nothing>()
    object InProgress : Result<Nothing>()
}

val action = when(result) {
    is Result.Success -> { }
    is Result.Error -> { }
}

Pour obtenir cet avantage intéressant même lorsque nous utilisons when en tant qu'instruction, ajoutez cette propriété d'extension d'assistance:

val <T> T.exhaustive: T
    get() = this

when(result){
    is Result.Success -> { }
    is Result.Error -> { }
}.exhaustive

Comme tous les sous-types d'une classe scellée sont connus, l'EDI peut remplir toutes les branches possibles d'une instruction when pour nous:

Cette fonctionnalité brille vraiment avec des hiérarchies de classes scellées plus complexes car l'EDI peut reconnaître toutes les branches:

sealed class Result<out T : Any> {
  data class Success<out T : Any>(val data: T) : Result<T>()
  sealed class Error(val exception: Exception) : Result<Nothing>() {
     class RecoverableError(exception: Exception) : Error(exception)
     class NonRecoverableError(exception: Exception) : 
                                               Error(exception)
  }
  object InProgress : Result<Nothing>()
}

      

Sous la capuche

Alors, qu'est-ce qui fait que les classes scellées se comportent comme elles le font? Voyons ce qui se passe dans le code Java décompilé:

sealed class Result
data class Success(val data: Any) : Result()
data class Error(val exception: Exception) : Result()
@Metadata(
…
d2 = {“Lio/testapp/Result;”, “T”, “”, “()V”, “Error”, “Success”, “Lio/testapp/Result$Success;”, “Lio/testapp/Result$Error;” …}
)
public abstract class Result {
    private Result() {}
    // $FF: synthetic method
    public Result(DefaultConstructorMarker $constructor_marker) {
        this();
    }
}

Le Resultest implémenté comme une classe abstraite avec deux constructeurs:

• Un constructeur par défaut privé
• Un constructeur synthétique qui ne peut être utilisé que par le compilateur Kotlin

public final class Success extends Result {
    @NotNull
    private final Object data
    
    public Success(@NotNull Object data) {
      
       super((DefaultConstructorMarker)null);
       this.data = data;
    }