Como usar When no Kotlin

Postado em 15/04/2025

Por Tiago Aguiar 4 min de leitura

When Kotlin

Vamos ser sinceros: no começo, entender lógica condicional pode parecer um quebra-cabeça. O tradicional if/else é um dos primeiros blocos de construção, mas rapidamente vira uma bagunça quando você precisa lidar com muitas possibilidades.

E se existisse uma forma mais elegante de lidar com isso? Pois bem, existe. O Kotlin tem uma ferramenta chamada when que resolve esse problema com muita clareza – principalmente quando você está dando os primeiros passos no desenvolvimento Android.

Neste artigo, vamos descomplicar o when, explicando como ele funciona, quando usar e por que ele pode deixar seu código mais limpo, legível e fácil de manter.

Do if/else ao when: Evoluindo a Lógica Condicional

O if/else funciona bem quando há poucas condições. Mas imagine um cenário típico de e-commerce: aplicar descontos diferentes com base no ID do produto, tipo de cliente e valor do pedido. Essa lógica, se feita só com if, rapidamente se transforma em um código difícil de ler e manter.

É aqui que o when brilha: ele permite verificar um valor e executar o bloco correspondente, sem aninhamentos malucos ou repetições desnecessárias.

Sintaxe do when: Entendendo o Básico

A estrutura básica do when no Kotlin é esta:

  
when (expressao) {
    valor1 -> { blocoDeCodigo1 }
    valor2 -> { blocoDeCodigo2 }
    else -> { blocoPadrao } // Opcional
}

O que cada parte significa?

expressao: O valor que você quer verificar. Pode ser um número, uma String, uma enum, e muito mais.
valor1, valor2, …: Os possíveis valores que serão comparados com a expressão.
->: Indica o que deve ser executado se a correspondência for encontrada.
else: Um caso padrão, que será executado se nenhum valor anterior a combinar com a expressão. Ele é opcional, mas altamente recomendado.

Vamos aplicar o when a um caso comum como calcular o desconto de um produto com base no ID.

  
fun calcularDesconto(idProduto: Int): Double {
    return when (idProduto) {
        1 -> 0.10 // 10% de desconto
        2 -> 0.20 // 20%
        3 -> 0.05 // 5%
        else -> 0.00 // Sem desconto
    }
}

fun main() {
    println("Desconto do produto 1: ${calcularDesconto(1)}")
    println("Desconto do produto 2: ${calcularDesconto(2)}")
    println("Desconto do produto 4: ${calcularDesconto(4)}") // Caso padrão
}

Note que, com if/else, esse código teria no mínimo umas 6 linhas a mais. O when permite mapear o valor de entrada para uma saída específica de forma direta e limpa, sem repetir a variável ou criar estruturas aninhadas.

Usando Expressões e Blocos Mais Complexos no when

Outra vantagem do when é que ele aceita lógica adicional dentro de seus blocos, o que o torna ainda mais poderoso.

Vamos imaginar que queremos aplicar um desconto adicional de 10% se o valor do pedido ultrapassar R$ 100, mesmo que o produto não tenha desconto fixo.

  
fun calcularDesconto(idProduto: Int, valorPedido: Double): Double {
    return when (idProduto) {
        1 -> 0.10
        2 -> 0.20
        3 -> 0.05
        else -> {
            if (valorPedido > 100.0) 0.10 else 0.00
        }
    }
}

fun main() {
    println("Desconto produto 1, pedido R$100: ${calcularDesconto(1, 100.0)}")
    println("Desconto produto 1, pedido R$200: ${calcularDesconto(1, 200.0)}")
    println("Desconto produto 3, pedido R$50: ${calcularDesconto(3, 50.0)}")
    println("Desconto produto 10, pedido R$150: ${calcularDesconto(10, 150.0)}")
}

Mesmo que o produto 10 não tenha um desconto fixo, ele recebe 10% se o pedido for acima de R$ 100. Isso mostra que podemos usar if dentro do when, tornando a lógica muito mais expressiva.

Dicas Extras sobre o when

O when não precisa sempre de uma expressão. Dá pra usar como substituto do if/else puro:

  
when {
    valor > 100 -> println("Pedido alto")
    valor in 50.0..100.0 -> println("Pedido médio")
    else -> println("Pedido baixo")
}

Ele também funciona com tipos específicos, como enums:

  
enum class TipoCliente { VIP, REGULAR, NOVO }

fun descontoPorCliente(tipo: TipoCliente): Double {
    return when (tipo) {
        TipoCliente.VIP -> 0.30
        TipoCliente.REGULAR -> 0.10
        TipoCliente.NOVO -> 0.00
    }
}

Concluindo

O when é simples, direto e poderoso. Ele resolve a maior parte dos casos em que você usaria um monte de if/else, deixando o código mais elegante e fácil de manter.

Em apps Android, esse tipo de lógica pode ser usado em ViewModels, no processamento de dados vindos da API, ou até mesmo para exibir mensagens diferentes na UI, dependendo do estado do app.

Experimente criar funções com when usando String, Boolean ou até mesmo tipos personalizados. Teste múltiplos case para o mesmo resultado e use o when para mapear enums para recursos do Android, como textos ou cores por exemplo.

Se você está começando com Kotlin, dominar o when vai te dar mais clareza e controle na hora de escrever código.

Continue praticando – e, claro, use esse recurso para deixar seu app Android muito mais organizado.

Espero ter ajudado no seu aprendizado!

Android

#kotlin