Vocabulário Kotlin - Classes Seladas

Freqüentemente, precisamos representar um conjunto limitado de possibilidades; uma solicitação da web é bem-sucedida ou falha, um Usersó pode ser um Pro-User ou um usuário padrão.

Para modelar isso, poderíamos usar um enum, mas isso acarreta uma série de limitações. As classes Enum permitem apenas uma única instância de cada valor e não podem codificar mais informações sobre cada tipo, por exemplo, um Errorcaso com uma Exceptionpropriedade associada .

Você poderia usar uma classe abstrata e várias extensões, mas isso perde a vantagem do conjunto restrito de tipos trazida por enums. As classes seladas fornecem o melhor dos dois mundos: a liberdade de representação de classes abstratas e o conjunto restrito de tipos de enums. Continue lendo para saber mais sobre as classes lacradas ou, se preferir um vídeo, confira aqui:

O básico das aulas seladas

Como as classes abstratas, as classes seladas permitem que você represente hierarquias. As classes filhas podem ser qualquer tipo de classe: uma classe de dados, um objeto , uma classe regular ou mesmo outra classe selada. Ao contrário das classes abstratas, você deve definir essas hierarquias no mesmo arquivo ou como classes aninhadas.

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

Freqüentemente, queremos lidar com todos os tipos possíveis:

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

Para obter esse benefício bacana, mesmo quando estamos usando quando como uma instrução, adicione esta propriedade de extensão auxiliar:

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

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

Como todos os subtipos de uma classe selada são conhecidos, o IDE pode preencher todos os ramos possíveis de uma instrução when para nós:

Este recurso realmente brilha com hierarquias de classes seladas mais complexas, pois o IDE pode reconhecer todas as ramificações:

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

      

Sob o capô

Então, o que faz as classes seladas se comportarem como o fazem? Vamos ver o que está acontecendo no código Java descompilado:

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

O Resulté implementado como uma classe abstrata com dois construtores:

• Um construtor padrão privado
• Um construtor sintético que só pode ser usado pelo compilador Kotlin

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