Kotlin Academy · Aula

Operadores is e as

Verificações e conversões de tipo

Operadores is e as é 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.

Verificando e convertendo tipos

O Kotlin oferece dois operadores para trabalhar com tipos em tempo de execução:

is verifica se um valor é de determinado tipo
as converte um valor para determinado tipo

Ambos têm variantes seguras, que você aprenderá aqui.

O operador is

is retorna um booleano informando se um valor corresponde a um tipo.

Ele é a base das conversões inteligentes.

fun main() {
    val x: Any = "hello"
    println(x is String)
    println(x is Int)
}

Verificação negada com !is

Use !is para testar se um valor NÃO é de determinado tipo.

Isso fica natural em cláusulas de proteção.

fun main() {
    val x: Any = 42
    if (x !is String) {
        println("not a string")
    }
}

O operador as

as realiza uma conversão explícita. Se o valor realmente for desse tipo, você o receberá de volta com o tipo correto.

Use-o quando o compilador não puder inferir o tipo sozinho.

fun main() {
    val x: Any = "hello"
    val s = x as String
    println(s.length)
}

Quando as falha

Se o valor não for do tipo de destino, as lançará uma ClassCastException.

Esta é a variante insegura, portanto use-a somente quando tiver certeza.

fun main() {
    val x: Any = 42
    try {
        val s = x as String
        println(s)
    } catch (e: ClassCastException) {
        println("Cannot cast Int to String")
    }
}

A conversão segura as?

as? é a conversão segura. Ela retorna o valor convertido para o tipo ou null se a conversão for impossível.

Nenhuma exceção é lançada.

fun main() {
    val x: Any = 42
    val s = x as? String
    println(s)
}

Conversão segura com Elvis

Combine as? com Elvis para fornecer um fallback quando a conversão falhar.

Esse é um padrão limpo que evita falhas.

fun main() {
    val x: Any = 42
    val s = (x as? String) ?: "default"
    println(s)
}

is ativa conversões inteligentes

Depois de uma verificação com is, geralmente você não precisa de as, pois as conversões inteligentes entram em ação.

Use a conversão explícita com as somente quando a conversão inteligente não puder ser aplicada.

fun main() {
    val x: Any = "smart"
    if (x is String) {
        println(x.uppercase()) // smart cast, no as needed
    }
}

Conversões em coleções

As conversões seguras são úteis ao filtrar coleções com tipos mistos.

filterIsInstance usa is internamente para manter apenas os elementos correspondentes.

fun main() {
    val items: List<Any> = listOf(1, "two", 3, "four")
    val strings = items.filterIsInstance<String>()
    println(strings)
}

Escolhendo o operador certo

Um guia simples:

Precisa de um booleano? use is
Tem certeza do tipo? use as
Não tem certeza? use as? com um fallback

fun describe(x: Any): String {
    val text = x as? String ?: return "not text"
    return "text of length " + text.length
}

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

Juntando tudo

Os operadores de tipo oferecem controle total:

is / !is verificam tipos
as converte, mas pode lançar uma exceção
as? converte com segurança, retornando nulo em caso de falha

fun main() {
    val values: List<Any> = listOf(1, "hi", 2.5)
    for (v in values) {
        when {
            v is Int -> println("int " + v)
            v is String -> println("string " + v)
            else -> println("other")
        }
    }
}

Verificação rápida

Teste sua compreensão de is e as.

Recapitulação

Você aprendeu os operadores de tipo:

is e !is para verificações de tipo
as para conversões que podem lançar exceções
as? para conversões seguras que retornam nulo

A seguir, você tornará when exaustivo para abranger todos os casos.

Perguntas Frequentes

A aula “Operadores is e as” é grátis?

Sim — o texto completo de “Operadores is e as” é 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 “Operadores is e as”?

Verificações e conversões de tipo 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 “Operadores is e as”?

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