Android Academy · Aula

Tipos anuláveis versus não anuláveis

O marcador de tipo ?.

Tipos anuláveis versus não anuláveis é 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.

Por que a segurança contra nulos é importante

Muitos travamentos em aplicativos Android vêm de um único erro: usar um valor que, na verdade, está ausente. Em outras linguagens, isso se transforma em uma temida NullPointerException durante a execução.

O Kotlin trata disso durante a compilação. O sistema de tipos acompanha quais valores podem ser null e quais nunca podem. Esta lição apresenta a base desse sistema.

Tipos não nulos

Por padrão, um tipo do Kotlin não pode conter null. Um String sempre aponta para uma string real.

Se você tentar atribuir null a ele, o código nem sequer será compilado. Esse é o padrão seguro.

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

Null é rejeitado

Observe o que acontece quando você tenta colocar null em um tipo não nulo.

O compilador impede você imediatamente. Você nunca chega à execução com um erro oculto.

val name: String = null  // Compile error:
// Null can not be a value of a non-null type String

Tipos anuláveis com ?

Às vezes, um valor pode realmente estar ausente, como o nome do meio opcional de um usuário. Você opta por isso adicionando ? ao tipo.

Um String? pode conter uma string real ou null. O ponto de interrogação marca o tipo como anulável.

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

Dois tipos diferentes

String e String? não são o mesmo tipo. O segundo é um tipo mais abrangente que inclui o valor null.

Essa distinção permite que o compilador proteja você. Ele sabe exatamente onde null pode aparecer.

val sure: String = "hello"
val maybe: String? = "hello"
// maybe could later be null; sure never can

Você não pode usar um anulável diretamente

O compilador não permitirá que você chame um método em um valor anulável sem verificá-lo primeiro.

Como middleName poderia ser null, chamar .length nele é um erro de compilação. Você precisa tratar o caso nulo.

val middleName: String? = null
println(middleName.length)
// Error: only safe (?.) or non-null (!!) calls allowed

Verificando com if

A forma mais simples de usar um valor anulável é verificá-lo com uma condição if.

Dentro do ramo em que você comprovou que ele não é nulo, o Kotlin o converte automaticamente para um tipo não nulo, então .length funciona.

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

Conversões inteligentes

Após uma verificação nula bem-sucedida, o compilador se lembra de que o valor não é nulo no restante daquele bloco. Isso é chamado de conversão inteligente.

Você não escreveu nenhuma conversão. O Kotlin acompanhou isso automaticamente para você.

fun describe(s: String?) {
    if (s == null) return
    // s is now treated as String here
    println("Length is " + s.length)
}

Parâmetros de funções

O fato de um parâmetro ser anulável faz parte do contrato da função. Um parâmetro não nulo promete aos chamadores que nunca receberá null.

Um parâmetro anulável indica que uma entrada ausente é esperada e tratada.

fun greet(name: String) {
    println("Hi, " + name)
}
// greet(null) would not compile

Tipos de retorno podem ser anuláveis

Uma função pode retornar null para indicar que nada foi encontrado. Marque o tipo de retorno com ?.

Assim, os chamadores sabem que precisam verificar o resultado antes de usá-lo.

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

Prefira tipos não nulos

Uma boa regra: prefira tipos não nulos. Adicione ? somente quando um valor puder realmente estar ausente.

Isso mantém seu código fiel à realidade. Quanto menos tipos anuláveis você tiver, menos verificações nulas precisará fazer depois.

// Prefer this:
val score: Int = 0
// Over this, unless null is meaningful:
val maybeScore: Int? = null

Verificação rápida

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

Recapitulação

Por padrão, os tipos do Kotlin não são nulos e rejeitam null durante a compilação. Adicione ? para tornar um tipo anulável quando um valor puder estar ausente.

Você não pode usar um valor anulável diretamente. Uma verificação nula o converte automaticamente para não nulo, permitindo usá-lo com segurança. A seguir, você aprenderá formas mais curtas de tratar valores anuláveis.

Perguntas Frequentes

A aula “Tipos anuláveis versus não anuláveis” é grátis?

Sim — o texto completo de “Tipos anuláveis versus não anuláveis” é 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 “Tipos anuláveis versus não anuláveis”?

O marcador de tipo ?. 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 “Tipos anuláveis versus não anuláveis”?

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