Kotlin Vocabulary - Sealed Classes

Oft müssen wir eine begrenzte Anzahl von Möglichkeiten darstellen; Eine Webanforderung ist entweder erfolgreich oder schlägt fehl. Sie Userkann nur ein Pro-Benutzer oder ein Standardbenutzer sein.

Um dies zu modellieren, könnten wir eine verwenden enum, dies birgt jedoch eine Reihe von Einschränkungen. Aufzählungsklassen erlauben nur eine einzelne Instanz jedes Werts und können nicht mehr Informationen zu jedem Typ codieren, z. B. einen ErrorFall mit einer zugeordneten ExceptionEigenschaft.

Sie könnten eine abstrakte Klasse und eine Reihe von Erweiterungen verwenden, dies verliert jedoch den eingeschränkten Vorteil von Typen durch Aufzählungen. Versiegelte Klassen bieten das Beste aus beiden Welten: die Repräsentationsfreiheit abstrakter Klassen und die eingeschränkte Anzahl von Aufzählungstypen. Lesen Sie weiter, um mehr über versiegelte Klassen zu erfahren, oder sehen Sie es sich hier an, wenn Sie ein Video bevorzugen:

Die Grundlagen versiegelter Klassen

Wie abstrakte Klassen können Sie mit versiegelten Klassen Hierarchien darstellen. Die untergeordneten Klassen können jede Art von Klasse sein: eine Datenklasse, ein Objekt , eine reguläre Klasse oder sogar eine andere versiegelte Klasse. Im Gegensatz zu abstrakten Klassen müssen Sie diese Hierarchien in derselben Datei oder als verschachtelte Klassen definieren.

// 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

Oft wollen wir alle möglichen Typen behandeln:

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

Fügen Sie diese Hilfserweiterungseigenschaft hinzu, um diesen nützlichen Vorteil auch dann zu erzielen, wenn wir when als Anweisung verwenden:

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

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

Da alle Untertypen einer versiegelten Klasse bekannt sind, kann die IDE alle möglichen Zweige einer when-Anweisung für uns füllen:

Diese Funktion glänzt wirklich mit komplexeren Hierarchien versiegelter Klassen, da die IDE alle Zweige erkennen kann:

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

      

Unter der Haube

Warum verhalten sich versiegelte Klassen so wie sie? Mal sehen, was im dekompilierten Java-Code los ist:

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

Das Resultist als abstrakte Klasse mit zwei Konstruktoren implementiert:

• Ein privater Standardkonstruktor
• Ein synthetischer Konstruktor, der nur vom Kotlin-Compiler verwendet werden kann

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