Kotlin Academy · Aula

Tipos Nulos e Não Nulos

Noções básicas do sistema de tipos

Aula 1 de 413 etapas

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

Por que a segurança contra nulos é importante

O infame NullPointerException já encerrou inúmeros programas. O Kotlin enfrenta esse problema diretamente ao tornar a possibilidade de nulo parte do sistema de tipos.

No Kotlin, o compilador sabe se um valor pode ser null ou não e força você a tratar essa possibilidade antes que surjam problemas.

Tipos não nulos

Por padrão, todo tipo no Kotlin é não nulo. Uma variável do tipo String nunca pode conter null.

Essa garantia é imposta em tempo de compilação, portanto você pode usar o valor livremente, sem verificações.

fun main() {
    val name: String = "Alice"
    println(name.length)
}

A atribuição de nulo é rejeitada

Se tentar colocar null em um tipo não nulo, o compilador interromperá você imediatamente.

A linha abaixo não seria compilada porque String não aceita null:

val name: String = null → erro

fun main() {
    val city: String = "Paris"
    // val broken: String = null // compile error
    println(city)
}

Tipos anuláveis

Para permitir null, adicione um ponto de interrogação depois do tipo: String?.

Esse é um tipo anulável. Ele pode conter um valor real ou null.

fun main() {
    val maybeName: String? = null
    println(maybeName)
}

Anulável versus não nulo

As duas declarações parecem quase idênticas, mas comportam-se de maneiras muito diferentes:

val a: String → nunca é nulo
val b: String? → pode ser nulo

Um único ? muda todo o contrato da variável.

fun main() {
    val a: String = "hi"
    val b: String? = "hi"
    println(a)
    println(b)
}

O compilador protege o acesso a valores anuláveis

Você não pode chamar métodos diretamente em um valor anulável. O compilador recusa a operação porque o valor pode ser null.

A linha comentada abaixo não seria compilada:

maybe.length em um String? → erro

fun main() {
    val maybe: String? = "text"
    // println(maybe.length) // compile error
    println(maybe)
}

Verificando se há nulo

Uma maneira simples de usar um valor anulável é fazer uma verificação explícita com if.

Dentro do bloco if, o Kotlin sabe que o valor não é nulo e permite que você o use com segurança.

fun main() {
    val maybe: String? = "hello"
    if (maybe != null) {
        println(maybe.length)
    }
}

Nulo em parâmetros de funções

Os tipos de parâmetros também seguem essa regra. Um parâmetro tipado como String deve receber um valor real, enquanto String? aceita null.

Isso torna as assinaturas das funções autoexplicativas quanto ao que aceitam.

fun greet(name: String?) {
    if (name != null) {
        println("Hello, " + name)
    } else {
        println("Hello, guest")
    }
}

fun main() {
    greet("Mia")
    greet(null)
}

Tipos de retorno anuláveis

As funções podem retornar tipos anuláveis para expressar que um resultado pode estar ausente.

Assim, o chamador é obrigado a tratar o possível null antes de usar o resultado.

fun firstChar(text: String?): Char? {
    if (text == null || text.isEmpty()) return null
    return text[0]
}

fun main() {
    println(firstChar("Kotlin"))
    println(firstChar(null))
}

Inferência padrão

Quando você atribui um literal, o Kotlin infere automaticamente um tipo não nulo.

val n = "text" → String inferido

Para torná-lo anulável, você precisa declarar o tipo explicitamente com ?.

fun main() {
    val n = "text" // inferred String (non-null)
    val m: String? = "text" // explicit nullable
    println(n.length)
    println(m)
}

Reunindo os conceitos

O sistema de tipos divide os valores em dois grupos claros:

Não nulos: sempre seguros para usar
Anuláveis: devem ser tratados antes do uso

Essa distinção transfere os erros relacionados a nulos das falhas em tempo de execução para erros em tempo de compilação.

fun main() {
    val safe: String = "always here"
    val risky: String? = null
    println(safe.uppercase())
    if (risky != null) println(risky.uppercase()) else println("no value")
}

Verificação rápida

Teste sua compreensão dos tipos anuláveis e não nulos.

Responda na aula interativa

Resumo

Você aprendeu os fundamentos da segurança contra nulos no Kotlin:

Por padrão, todo tipo é não nulo
Adicionar ? cria um tipo anulável
O compilador bloqueia o acesso inseguro a valores anuláveis
Uma verificação if (x != null) permite usar o valor com segurança

Em seguida, você aprenderá os operadores concisos que tornam o trabalho com valores anuláveis simples.

Grátis para começar

Aprenda Kotlin com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 51
Aulas: 203

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Tipos Nulos e Não Nulos” é grátis?

Sim — o texto completo de “Tipos Nulos e Não 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 Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “Tipos Nulos e Não Nulos”?

Noções básicas do sistema de tipos 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 1 de 4.

Quanto tempo leva a aula “Tipos Nulos e Não 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 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