0Pricing
Kotlin Academy · Aula

when exaustivo com hierarquias seladas

Escreva expressões when completas que cubram cada variante selada.

when exaustivo com hierarquias seladas é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.

Expressão condicional exaustiva

Uma expressão when usada como expressão deve ser exaustiva — todo valor possível precisa ser tratado. As hierarquias seladas permitem que o compilador verifique isso por si só.

Expressão condicional não exaustiva em um tipo aberto

Para classes comuns, o compilador não consegue verificar todos os subtipos — ele exige um ramo else.

open class Shape
class Circle : Shape()
class Square : Shape()
fun describe(s: Shape) = when (s) {
    is Circle -> "circle"
    is Square -> "square"
    else      -> "unknown" // required
}
fun main() { println(describe(Circle())) }

Expressão condicional exaustiva em um tipo selado

Para uma classe selada, o compilador conhece todos os subtipos. Nenhum else é necessário se todos os casos forem abrangidos.

sealed class Result
class Success(val value: Int) : Result()
class Failure(val msg: String) : Result()
fun describe(r: Result) = when (r) {
    is Success -> "ok: ${r.value}"
    is Failure -> "err: ${r.msg}"
}
fun main() {
    println(describe(Success(42)))
    println(describe(Failure("nope")))
}

Interface selada

Interfaces seladas fornecem verificação exaustiva mesmo quando as classes precisam de herança múltipla.

sealed interface Animal
class Dog : Animal
class Cat : Animal
fun speak(a: Animal) = when (a) {
    is Dog -> "woof"
    is Cat -> "meow"
}
fun main() {
    println(speak(Dog()))
    println(speak(Cat()))
}

Conversões inteligentes nos ramos

Dentro de cada ramo is, o Kotlin converte automaticamente a variável para o tipo específico — não é necessária nenhuma conversão manual.

sealed class Event
data class Click(val x: Int, val y: Int) : Event()
data class Key(val char: Char) : Event()
fun handle(e: Event) = when (e) {
    is Click -> "clicked at (${e.x},${e.y})" // smart-cast
    is Key   -> "key=${e.char}"
}
fun main() {
    println(handle(Click(10, 20)))
    println(handle(Key('A')))
}

Esquecer um caso

Se adicionar uma nova variante posteriormente, toda expressão when exaustiva que ainda usar o tipo selado como expressão deixará de compilar — uma excelente rede de segurança.

sealed class Status
object Idle : Status()
object Running : Status()
// If we add object Done : Status(), every exhaustive when must update.
fun text(s: Status): String = when (s) {
    is Idle -> "idle"
    is Running -> "running"
}
fun main() { println(text(Idle)) }

Tipos selados com classes de dados

Um padrão comum: classes de dados como variantes de uma hierarquia selada.

sealed class UiState {
    object Loading : UiState()
    data class Success(val data: List<String>) : UiState()
    data class Error(val message: String) : UiState()
}
fun render(state: UiState) = when (state) {
    UiState.Loading -> "loading..."
    is UiState.Success -> "got ${state.data.size} items"
    is UiState.Error -> "error: ${state.message}"
}
fun main() {
    println(render(UiState.Loading))
    println(render(UiState.Success(listOf("a", "b"))))
    println(render(UiState.Error("404")))
}

Usar uma expressão condicional como instrução

Quando usada como instrução, e não como expressão, when não precisa ser exaustiva. Porém, perde-se a rede de segurança.

sealed class Cmd
object Start : Cmd()
object Stop : Cmd()
fun execute(c: Cmd) {
    // Statement form: no error if incomplete (avoid this style)
    when (c) {
        Start -> println("started")
        Stop -> println("stopped")
    }
}
fun main() { execute(Start); execute(Stop) }

Forçar a verificação de exaustividade em uma instrução

Atribua when a um valor (ou use o recurso .exhaustive) para que o compilador imponha o tratamento de todos os casos.

sealed class Cmd
object Start : Cmd()
object Stop : Cmd()
fun execute(c: Cmd) {
    val handled: Unit = when (c) { // expression context now
        Start -> println("started")
        Stop -> println("stopped")
    }
}
fun main() { execute(Start) }

Ramos com vários casos

Agrupe casos com vírgulas para compartilhar o mesmo corpo entre várias variantes.

sealed class Event
class Click : Event()
class Tap : Event()
class Drag : Event()
fun isPointer(e: Event) = when (e) {
    is Click, is Tap, is Drag -> true
}
fun main() { println(isPointer(Tap())) }

Tipos selados aninhados

As hierarquias seladas podem ser aninhadas — a verificação de exaustividade continua funcionando em árvores profundas.

sealed class Network {
    sealed class Wifi : Network() {
        object Open : Wifi()
        data class Secured(val ssid: String) : Wifi()
    }
    object Cellular : Network()
}
fun describe(n: Network) = when (n) {
    Network.Wifi.Open -> "open wifi"
    is Network.Wifi.Secured -> "secured: ${n.ssid}"
    Network.Cellular -> "cellular"
}
fun main() {
    println(describe(Network.Wifi.Secured("home")))
    println(describe(Network.Cellular))
}

Verificação rápida

Qual é o principal benefício de usar when com hierarquias seladas?

Recapitulação

Combine classes ou interfaces seladas com when para obter exaustividade verificada em tempo de compilação. As conversões inteligentes simplificam os corpos dos ramos. Use como expressão (ou atribua o resultado) para forçar a verificação; agrupe casos com vírgulas; aninhe tipos selados para representar estados em forma de árvore.

Perguntas Frequentes

A aula “when exaustivo com hierarquias seladas” é grátis?

Sim — o texto completo de “when exaustivo com hierarquias seladas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “when exaustivo com hierarquias seladas”?

Escreva expressões when completas que cubram cada variante selada. Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kotlin Academy?

Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “when exaustivo com hierarquias seladas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kotlin Academy?

Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. sealed class vs sealed interface: quando usar cada uma
  2. when exaustivo com hierarquias seladas
  3. Modelando o estado da interface com classes seladas
  4. Aninhando e combinando hierarquias seladas
← Voltar para Kotlin Academy