Kotlin Academy · Aula

Tipos de Plataforma

Anulabilidade proveniente de Java

Tipos de Plataforma é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 4 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.

Kotlin encontra Java

O Kotlin é executado na JVM e chama código Java constantemente. Porém, o Java não tem o conceito de tipos anuláveis e não nulos.

Então, como o Kotlin trata um valor vindo do Java? Por meio dos tipos de plataforma.

O que é um tipo de plataforma

Um tipo de plataforma é um tipo que o Kotlin obtém do Java cuja nulidade é desconhecida.

O Kotlin o exibe como String! nas mensagens de erro. A exclamação significa: pode ser nulo ou não nulo; o Kotlin não imporá uma escolha.

Verificação flexível

Para tipos de plataforma, o Kotlin flexibiliza suas verificações de nulidade. Você pode tratar o valor como não nulo sem um erro do compilador.

A desvantagem: se ele realmente for nulo, você obterá uma NullPointerException em tempo de execução.

Você escolhe o tipo

Ao armazenar um valor de tipo de plataforma, você decide como tipá-lo:

como não nulo String → conveniente, mas arriscado
como anulável String? → seguro e explícito

Este exemplo em Kotlin simula essa escolha.

fun fromJava(): String? = "value from Java"

fun main() {
    val safe: String? = fromJava()
    println(safe?.length)
}

A escolha arriscada

Se você presumir que o valor não é nulo e a origem retornar nulo, a falha ocorrerá na atribuição ou no primeiro uso.

Esse é o perigo oculto dos tipos de plataforma.

fun fromJava(): String? = null

fun main() {
    try {
        val risky: String = fromJava()!!
        println(risky.length)
    } catch (e: NullPointerException) {
        println("Null came from the Java side")
    }
}

As anotações ajudam

As bibliotecas Java podem usar anotações como @Nullable e @NotNull.

Quando presentes, o Kotlin as respeita e fornece um String? ou String adequado em vez de um tipo de plataforma.

Boa prática: presuma que pode ser nulo

Ao chamar código Java sem anotações, o hábito seguro é tratar o resultado como anulável.

Declare sua variável com ? e use chamadas seguras, assim como faria com qualquer valor anulável do Kotlin.

fun fromJava(): String? = "data"

fun main() {
    val value: String? = fromJava()
    val length = value?.length ?: 0
    println(length)
}

Fronteiras defensivas

Trate a fronteira com o Java como não confiável. Valide os valores ou forneça valores padrão assim que eles entrarem no seu código Kotlin.

Depois disso, o restante do seu código trabalhará com tipos Kotlin consistentes.

fun fromJava(): String? = null

fun main() {
    val name = fromJava() ?: "default"
    // from here on, name is a clean non-null String
    println(name.uppercase())
}

Por que o Kotlin permite isso

O Kotlin poderia forçar todo valor Java a ser anulável, mas isso tornaria a interoperabilidade com Java excessivamente verbosa.

Os tipos de plataforma são um compromisso pragmático: conveniência com a opção de ser rigoroso.

Identificando tipos de plataforma

Você não escreverá String! por conta própria. Isso só aparece nas dicas do IDE e nas mensagens de erro quando você passa o cursor sobre valores provenientes do Java.

Ver o ! é o sinal para decidir deliberadamente sobre a nulidade.

Reunindo tudo

Os tipos de plataforma fazem a ponte entre Java e Kotlin:

Eles têm nulidade desconhecida, exibida como Type!
O Kotlin permite que você escolha entre anulável e não nulo
Quando estiver em dúvida, presuma que pode ser nulo para manter a segurança
As anotações eliminam as suposições

fun fromJava(): String? = "safe value"

fun main() {
    val value: String? = fromJava()
    println(value?.uppercase() ?: "missing")
}

Verificação rápida

Teste sua compreensão sobre os tipos de plataforma.

Recapitulação

Você aprendeu como a nulidade atravessa a fronteira com o Java:

Os tipos de plataforma têm nulidade desconhecida
O Kotlin flexibiliza as verificações, mas uma suposição errada causa um NPE em tempo de execução
Presuma que pode ser nulo e forneça valores padrão na fronteira
As anotações Java restauram os tipos adequados

Isso conclui o aprofundamento em segurança contra nulos.

Perguntas Frequentes

A aula “Tipos de Plataforma” é grátis?

Sim — o texto completo de “Tipos de Plataforma” é 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 “Tipos de Plataforma”?

Anulabilidade proveniente de Java 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 4 de 4.

Quanto tempo leva a aula “Tipos de Plataforma”?

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