0Pricing
Android Academy · Aula

Segurança contra Nulos

Compreenda o sistema de segurança contra nulos do Kotlin: tipos anuláveis, o operador de chamada segura, o operador Elvis e como eliminar NullPointerExceptions.

Segurança contra Nulos é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 1 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 erro de bilhões de dólares

Em Java, qualquer variável pode ser null, causando uma NullPointerException (NPE) durante a execução — uma das falhas mais comuns em aplicativos Android.

Tony Hoare, que inventou o valor nulo, chamou isso de seu erro de bilhões de dólares.

Kotlin elimina NPEs em tempo de compilação com seu sistema de segurança contra valores nulos.

Tipos anuláveis e não anuláveis

No Kotlin, os tipos são não anuláveis por padrão. Para permitir o valor nulo, adicione ? ao tipo:

  • String — nunca é nulo, garantidamente
  • String? — pode ser nulo

O compilador impõe essa regra — ele não permitirá atribuir null a um tipo não anulável.

Exemplo de tipos anuláveis

O compilador detecta erros com valores nulos antes de o aplicativo ser executado:

fun main() {
    val name: String = "Alice"   // never null
    // name = null  // COMPILE ERROR

    var nickname: String? = "Al"  // nullable
    nickname = null               // OK

    println(name)
    println(nickname)  // null
}

Operador de chamada segura ?.

O operador de chamada segura ?. chama um método somente se o objeto não for nulo. Se for nulo, retorna null em vez de causar uma falha.

nickname?.length → retorna o tamanho ou null se nickname for nulo.

Chamadas seguras em ação

Use ?. para acessar propriedades anuláveis com segurança:

fun main() {
    var text: String? = "Hello"
    println(text?.length)   // 5
    println(text?.uppercase()) // HELLO

    text = null
    println(text?.length)   // null (no crash!)
    println(text?.uppercase()) // null
}

Operador Elvis ?:

O operador Elvis ?: fornece um valor padrão quando uma expressão é nula:

val len = text?.length ?: 0

Leia assim: "o tamanho de text ou 0 se text for nulo".

O nome vem do emoji do Elvis 🕺, cujo cabelo se parece com ?:.

Exemplo do operador Elvis

Forneça valores padrão seguros com ?::

fun main() {
    var name: String? = "Bob"
    println(name?.length ?: 0)  // 3

    name = null
    println(name?.length ?: 0)  // 0

    val display = name ?: "Anonymous"
    println(display)  // Anonymous
}

Verificações de nulo com if

Dentro de um bloco if (x != null), Kotlin converte automaticamente o tipo anulável em não anulável — não é necessário usar ?. dentro do bloco.

Exemplo de conversão inteligente

Kotlin restringe o tipo depois de uma verificação de nulo:

fun printLength(text: String?) {
    if (text != null) {
        // 'text' is now String (non-nullable) here
        println("Length: ${text.length}") // no ?. needed
    } else {
        println("text is null")
    }
}

fun main() {
    printLength("Kotlin")  // Length: 6
    printLength(null)       // text is null
}

Verificação rápida

Qual é o resultado de null?.length ?: -1?

Recapitulação: segurança contra valores nulos

O sistema de segurança contra valores nulos do Kotlin elimina NPEs:

  • Os tipos não são anuláveis por padrão; adicione ? para permitir null
  • ?. chamada segura — retorna null em vez de causar uma falha
  • ?: operador Elvis — fornece um valor padrão quando o valor é nulo
  • Conversões inteligentes dentro de blocos if (x != null)

A seguir: estruturando o código com classes e objetos.

Perguntas Frequentes

A aula “Segurança contra Nulos” é grátis?

Sim — o texto completo de “Segurança contra Nulos” é 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 “Segurança contra Nulos”?

Compreenda o sistema de segurança contra nulos do Kotlin: tipos anuláveis, o operador de chamada segura, o operador Elvis e como eliminar NullPointerExceptions. 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 1 de 4.

Quanto tempo leva a aula “Segurança contra Nulos”?

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

  1. Segurança contra Nulos
  2. Classes e Objetos
  3. Classes de Dados e Classes Seladas
  4. Funções de Extensão e Funções de Ordem Superior
← Voltar para Android Academy