Kotlin Academy · Aula

Conversões Inteligentes

Converta automaticamente após verificações

Conversões Inteligentes é 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.

O que são conversões inteligentes

Depois que você verifica o tipo de um valor, o Kotlin mantém essa informação. Dentro do bloco verificado, ele trata o valor automaticamente como o tipo mais específico.

Esse recurso é chamado de conversão inteligente e elimina as conversões manuais.

Conversão inteligente após is

Quando uma verificação com is é bem-sucedida, você pode usar o valor como esse tipo sem escrever uma conversão.

O compilador a insere para você.

fun describe(x: Any) {
    if (x is String) {
        println(x.length) // x is smart-cast to String
    }
}

fun main() {
    describe("hello")
}

Conversão inteligente após verificação de nulo

As conversões inteligentes também funcionam com nulidade. Depois de confirmar que um valor não é nulo, ele passa a ser tratado como não nulo.

fun length(text: String?): Int {
    if (text != null) {
        return text.length // smart-cast to non-null String
    }
    return 0
}

fun main() {
    println(length("abc"))
    println(length(null))
}

Conversões inteligentes em when

As verificações de tipo dentro de when também ativam conversões inteligentes em cada ramo.

Essa é a maneira idiomática de lidar com vários tipos possíveis.

fun area(shape: Any): Double = when (shape) {
    is Int -> shape.toDouble()
    is String -> shape.length.toDouble()
    else -> 0.0
}

fun main() {
    println(area(5))
    println(area("hello"))
}

Conversão inteligente com retorno antecipado

Se você retornar antecipadamente quando um valor for nulo, o compilador saberá que ele não é nulo depois disso.

O restante da função usa o valor com segurança.

fun process(text: String?) {
    if (text == null) return
    println(text.uppercase()) // smart-cast here
}

fun main() {
    process("data")
    process(null)
}

Conversão inteligente com retorno usando Elvis

Combinar Elvis com return também ativa uma conversão inteligente para o código restante.

fun process(text: String?) {
    val safe = text ?: return
    println(safe.length) // safe is non-null
}

fun main() {
    process("hi")
    process(null)
}

Condições combinadas

As conversões inteligentes respeitam a lógica de condições combinadas usando &&.

Depois da verificação de tipo à esquerda, o lado direito já reconhece o tipo mais específico.

fun check(x: Any) {
    if (x is String && x.length > 3) {
        println("long string")
    } else {
        println("other")
    }
}

fun main() {
    check("hello")
    check(2)
}

Quando as conversões inteligentes falham

As conversões inteligentes precisam da garantia de que o valor não mudará entre a verificação e o uso.

Uma var mutável que possa mudar simultaneamente talvez não permita uma conversão inteligente. Prefira val para obter conversões inteligentes confiáveis.

fun main() {
    val text: String? = "stable"
    if (text != null) {
        println(text.length) // val smart-casts cleanly
    }
}

val local é mais seguro

Copiar um valor para um val local torna as conversões inteligentes confiáveis.

Esse é um padrão comum ao trabalhar com propriedades anuláveis.

class Box(val content: String?)

fun main() {
    val box = Box("item")
    val c = box.content
    if (c != null) {
        println(c.uppercase())
    }
}

Conversão inteligente versus conversão explícita

As conversões inteligentes substituem a maioria das conversões explícitas com as. Elas são mais seguras porque só se aplicam quando o tipo foi comprovado.

A seguir, você aprenderá diretamente sobre is e as explícitos.

fun main() {
    val x: Any = "text"
    if (x is String) {
        // no need for (x as String)
        println(x.reversed())
    }
}

Juntando tudo

As conversões inteligentes permitem que o compilador restrinja os tipos automaticamente:

Após verificações com is → conversão para esse tipo
Após verificações de nulo → conversão para um tipo não nulo
Funcionam em if, when e após retornos antecipados
São mais confiáveis com val

fun render(x: Any): String {
    if (x is Int) return "number " + x
    if (x is String) return "text " + x.uppercase()
    return "unknown"
}

fun main() {
    println(render(7))
    println(render("go"))
}

Verificação rápida

Teste sua compreensão das conversões inteligentes.

Recapitulação

Você aprendeu sobre conversões inteligentes:

As verificações de tipo e de nulo restringem o tipo automaticamente
Elas funcionam em if, when e após retornos antecipados
val produz as conversões inteligentes mais confiáveis

A seguir, você estudará diretamente os operadores is e as.

Perguntas Frequentes

A aula “Conversões Inteligentes” é grátis?

Sim — o texto completo de “Conversões Inteligentes” é 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 “Conversões Inteligentes”?

Converta automaticamente após verificações 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 “Conversões Inteligentes”?

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