Kotlin Academy · Aula

Enumerações com when

Tratamento exaustivo

Enumerações com when é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 3 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.

Enumerações combinam bem com when

A expressão when é a maneira natural de ramificar com base em uma enumeração. Cada constante recebe sua própria ramificação.

enum class Light { RED, YELLOW, GREEN }

fun action(l: Light) = when (l) {
    Light.RED -> "Stop"
    Light.YELLOW -> "Slow"
    Light.GREEN -> "Go"
}

fun main() {
    println(action(Light.GREEN))
}

Exaustividade

Quando when é usado como uma expressão sobre uma enumeração e abrange todas as constantes, não é necessária uma ramificação else. O compilador verifica a completude.

enum class Coin { HEADS, TAILS }

fun flip(c: Coin) = when (c) {
    Coin.HEADS -> "Win"
    Coin.TAILS -> "Lose"
}

fun main() {
    println(flip(Coin.HEADS))
}

O compilador protege você

Se você adicionar uma nova constante mais tarde, mas esquecer uma ramificação, o compilador informará um erro. Isso torna a evolução conjunta de enumerações e when muito segura.

enum class Size { S, M, L }

fun label(s: Size) = when (s) {
    Size.S -> "Small"
    Size.M -> "Medium"
    Size.L -> "Large"
}

fun main() {
    println(label(Size.M))
}

Importando constantes

Você pode importar membros da enumeração para remover o prefixo do tipo dentro de when, tornando as ramificações mais curtas.

enum class Dir { UP, DOWN }

import Dir.UP
import Dir.DOWN

fun move(d: Dir) = when (d) {
    UP -> "y + 1"
    DOWN -> "y - 1"
}

fun main() {
    println(move(Dir.UP))
}

Agrupando ramificações

Várias constantes podem compartilhar uma ramificação quando listadas com vírgulas.

enum class Day { MON, TUE, WED, SAT, SUN }

fun kind(d: Day) = when (d) {
    Day.SAT, Day.SUN -> "Weekend"
    else -> "Weekday"
}

fun main() {
    println(kind(Day.SAT))
}

Retornando tipos diferentes

Cada ramificação pode produzir um valor; o when inteiro se torna esse valor.

enum class Tier { FREE, PRO }

fun limit(t: Tier): Int = when (t) {
    Tier.FREE -> 10
    Tier.PRO -> 1000
}

fun main() {
    println(limit(Tier.PRO))
}

when sem argumento

Você também pode ramificar com base em condições, mas, para enumerações, a forma com um assunto é mais clara e permite verificar a exaustividade.

enum class Mood { HAPPY, SAD }

fun emoji(m: Mood) = when (m) {
    Mood.HAPPY -> ":)"
    Mood.SAD -> ":("
}

fun main() {
    println(emoji(Mood.HAPPY))
}

Efeitos colaterais nas ramificações

As ramificações podem executar instruções, não apenas retornar valores.

enum class Cmd { START, STOP }

fun run(c: Cmd) {
    when (c) {
        Cmd.START -> println("Starting...")
        Cmd.STOP -> println("Stopping...")
    }
}

fun main() {
    run(Cmd.START)
}

Evite else quando possível

Usar else impede a verificação de exaustividade: uma nova constante cairia silenciosamente em else. Prefira ramificações explícitas para enumerações.

enum class State { ON, OFF }

fun text(s: State) = when (s) {
    State.ON -> "on"
    State.OFF -> "off"
}

fun main() {
    println(text(State.OFF))
}

Um roteador realista

Encaminhar funções de usuários para permissões é uma aplicação clara de when exaustivo.

enum class Role { ADMIN, USER, GUEST }

fun canDelete(r: Role) = when (r) {
    Role.ADMIN -> true
    Role.USER -> false
    Role.GUEST -> false
}

fun main() {
    println(canDelete(Role.ADMIN))
}

Combinando com propriedades

Você pode criar ramificações com base em uma enumeração e também usar suas propriedades dentro das ramificações.

enum class Coin(val cents: Int) { PENNY(1), DIME(10) }

fun describe(c: Coin) = when (c) {
    Coin.PENNY -> "Worth ${c.cents}"
    Coin.DIME -> "Worth ${c.cents}"
}

fun main() {
    println(describe(Coin.DIME))
}

Verificação rápida

Teste sua compreensão sobre enumerações com when.

Recapitulação

Você aprendeu a combinar enumerações com when:

Um when sobre uma enumeração pode ser exaustivo sem else.
O compilador exige que todas as constantes sejam abrangidas.
Agrupe constantes com vírgulas; cada ramificação produz um valor.
Evite else para manter a segurança da exaustividade.

enum class Light { RED, GREEN }

fun go(l: Light) = when (l) {
    Light.RED -> false
    Light.GREEN -> true
}

fun main() {
    println(go(Light.GREEN))
}

Perguntas Frequentes

A aula “Enumerações com when” é grátis?

Sim — o texto completo de “Enumerações com when” é 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 “Enumerações com when”?

Tratamento exaustivo 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 3 de 4.

Quanto tempo leva a aula “Enumerações com when”?

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

← Voltar para Kotlin Academy