Android Academy · Aula

Evitando NullPointerExceptions

Padrões para um código seguro.

Evitando NullPointerExceptions é uma aula grátis de Android 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 Android Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Android Academy inclui 4 aulas no total.

O objetivo: nenhum NPE

Uma NullPointerException, ou NPE, acontece quando o código usa algo que na verdade é nulo. O Kotlin foi projetado para tornar essas ocorrências raras.

Esta lição reúne as ferramentas que você aprendeu e alerta sobre as poucas maneiras pelas quais um NPE ainda pode ocorrer.

O operador !!

A asserção de não nulo !! instrui o compilador a confiar que um valor não é nulo. Se você estiver errado, ele lançará um NPE.

Ela remove a segurança, portanto use-a raramente e somente quando tiver certeza.

fun main() {
    val name: String? = "Ada"
    println(name!!.length)  // works, name is not null
}

!! pode causar uma falha

Se o valor realmente for nulo, !! lançará uma NullPointerException exatamente nessa linha.

Essa é a principal maneira de reintroduzir o problema que o Kotlin evita. Evite !! quando uma chamada segura ou o operador Elvis resolverem o caso.

val name: String? = null
println(name!!.length)
// throws KotlinNullPointerException

Prefira alternativas seguras

Quase todo uso de !! pode ser reescrito com ?. e ?:. A versão segura não pode causar uma falha.

Compare abaixo as formas arriscada e segura.

// Risky:
val len1 = name!!.length
// Safe:
val len2 = name?.length ?: 0

Valide antecipadamente

Trate o nulo no limite do seu código e, depois, trabalhe com valores não nulos internamente. Use Elvis com return ou throw para rejeitar antecipadamente uma entrada ausente.

Após essa proteção, o valor é convertido automaticamente para não nulo.

fun length(s: String?): Int {
    val text = s ?: return 0
    return text.length
}

requireNotNull

Quando um nulo realmente significa um erro no código, requireNotNull lança um erro claro e retorna o valor não nulo.

Ele é mais descritivo do que !!, pois permite adicionar uma mensagem.

fun start(config: String?) {
    val c = requireNotNull(config) { "config missing" }
    println(c.length)
}

Tipos de plataforma do Java

Os valores provenientes do Java têm nulidade desconhecida e são chamados de tipos de plataforma. O Kotlin não pode garantir que eles não sejam nulos.

Ao usar bibliotecas Java, declare explicitamente o tipo esperado e trate os nulos de forma preventiva.

// From Java: String maybe = obj.getName();
val name: String? = obj.name  // be safe
println(name?.length ?: 0)

Armadilha do lateinit

Uma lateinit var permite adiar a inicialização de uma propriedade não nula. Porém, usá-la antes da atribuição lança uma exceção.

Use lateinit somente quando tiver certeza de que o valor será definido antes de qualquer acesso.

lateinit var config: String
fun read() {
    println(config.length)
    // crashes if config was never set
}

Valores padrão em vez de nulos

Muitas vezes, você pode evitar totalmente a nulidade escolhendo um valor padrão sensato. Uma string vazia ou uma lista vazia frequentemente é melhor do que nulo.

Menos tipos anuláveis significam menos chances de ocorrer um NPE.

fun main() {
    val tags: List<String> = emptyList()
    println(tags.size)  // 0, never null
}

Um fluxo seguro

Este programa lê um valor opcional, transforma-o com segurança e sempre produz um resultado. Sem !!, sem falhas.

Esse é o estilo que você deve buscar em código Android real.

fun main() {
    val input: String? = null
    val result = input?.trim()?.uppercase() ?: "N/A"
    println(result)  // prints: N/A
}

Práticas recomendadas

Prefira tipos não nulos, trate os nulos nos limites usando Elvis e use ?.let para ações opcionais. Reserve !! para os casos raros em que o nulo é impossível.

Siga esses hábitos e NullPointerExceptions se tornarão coisa do passado.

val safe = data?.value ?: default
data?.let { handle(it) }

Verificação rápida

Teste sua compreensão sobre como evitar NullPointerExceptions.

Recapitulação

Os NPEs no Kotlin geralmente vêm de !!, de tipos de plataforma do Java ou de valores lateinit não inicializados. Evite-os preferindo tipos não nulos e operadores seguros.

Use ?., ?:, ?.let e validações como requireNotNull para manter o código livre de falhas. Agora você concluiu os fundamentos essenciais da segurança contra nulos no Kotlin.

Perguntas Frequentes

A aula “Evitando NullPointerExceptions” é grátis?

Sim — o texto completo de “Evitando NullPointerExceptions” é 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 Android Academy, atualize para CoddyKit PRO. O curso de Android Academy inclui 4 aulas no total.

O que vou aprender em “Evitando NullPointerExceptions”?

Padrões para um código seguro. Você pratica Android 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 Android Academy?

Nenhuma experiência prévia é necessária. Android 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 “Evitando NullPointerExceptions”?

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 Android Academy?

Sim. Cada aula de Android 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 Android Academy