Tipos anuláveis e o modificador ?
Declare variáveis anuláveis e entenda a segurança contra nulos do Kotlin em tempo de compilação.
Tipos anuláveis e o modificador ? é 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.
Segurança contra nulos no Kotlin
O Kotlin distingue, em tempo de compilação, entre tipos que podem conter null e tipos que não podem. O compilador impede a maioria das NullPointerExceptions antes da execução.
Tipo não anulável
Por padrão, um tipo do Kotlin não pode ser null. Tente atribuir null e o compilador recusará.
fun main() {
val name: String = "Ada"
// val nope: String = null // ERROR
println(name)
}Tipo anulável com ?
Anexe ? para permitir null. O compilador passa a tratar a variável como opcionalmente ausente.
fun main() {
val name: String? = null
println(name) // null
}Chamando métodos em valores anuláveis
Você não pode chamar um método diretamente em um valor anulável sem antes tratar o caso de null. O compilador recusará.
fun main() {
val name: String? = "Bob"
// println(name.length) // ERROR — name might be null
if (name != null) println(name.length) // smart cast
}Conversões inteligentes de tipo
Depois de uma verificação if (x != null), o Kotlin converte automaticamente x para um tipo não anulável dentro do ramo.
fun main() {
val name: String? = "Alice"
if (name != null) {
println("Length: ${name.length}") // safe, smart-cast
} else {
println("No name")
}
}Parâmetro de função anulável
Marque os parâmetros de função como anuláveis quando eles puderem estar ausentes. Quem chama a função deverá fornecer explicitamente um valor ou null.
fun greet(name: String?) {
if (name == null) println("Hello, stranger")
else println("Hello, $name")
}
fun main() {
greet("Sara")
greet(null)
}Tipo de retorno anulável
Uma função que retorna X? informa a quem a chama que pode retornar null — essa pessoa deverá tratar o caso.
fun findUser(id: Int): String? {
return if (id == 1) "Alice" else null
}
fun main() {
val u = findUser(2)
println(u ?: "no user")
}Propriedades anuláveis
As propriedades de uma classe também podem ser anuláveis. Isso é comum quando os campos são preenchidos posteriormente ou obtidos de forma opcional.
data class Profile(
val name: String,
val avatarUrl: String?
)
fun main() {
val p = Profile("Lee", null)
println(p.avatarUrl ?: "(no avatar)")
}Coleções anuláveis
Diferencie uma lista anulável List<T>? de uma lista de valores anuláveis List<T?>. Elas representam coisas diferentes.
fun main() {
val maybeList: List<Int>? = null
val listOfMaybe: List<Int?> = listOf(1, null, 3)
println(maybeList?.size) // null
println(listOfMaybe.size) // 3
}Comparação com Java
Os tipos Java que entram no Kotlin aparecem como tipos de plataforma (String!) — o Kotlin confia em você, mas não oferece segurança contra nulos. Sempre anote as APIs Java com @Nullable/@NotNull quando possível.
fun main() {
val maybeNull: String? = System.getenv("FOO") // null if unset
println("env FOO = ${maybeNull ?: "(unset)"}")
}Por que isso importa
A segurança contra nulos em tempo de compilação impede toda uma classe de falhas em tempo de execução. Adote o modificador ? — ele documenta a intenção e exige que o caso seja tratado.
fun divide(a: Int, b: Int): Int? = if (b == 0) null else a / b
fun main() {
val r1 = divide(10, 2) // 5
val r2 = divide(10, 0) // null — handled at call site
println("$r1, $r2")
}Verificação rápida
O que significa o ? no final de uma declaração de tipo?
Recapitulação
Por padrão, os tipos do Kotlin não são anuláveis. Adicione ? para permitir null. O compilador impõe o tratamento de nulos por meio de conversões inteligentes de tipo, chamadas seguras e do operador Elvis — impedindo a maioria das NullPointerExceptions antes da execução.
Perguntas Frequentes
A aula “Tipos anuláveis e o modificador ?” é grátis?
Sim — o texto completo de “Tipos anuláveis e o modificador ?” é 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 anuláveis e o modificador ?”?
Declare variáveis anuláveis e entenda a segurança contra nulos do Kotlin em tempo de compilação. 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 anuláveis e o modificador ?”?
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
- Tipos anuláveis e o modificador ?
- Chamada segura ?. e Elvis ?: em código real
- let, also e run com receptores anuláveis
- Operador !!: quando e por que evitá-lo