O que são tipos 'nullable' em Kotlin e como eles…

Os tipos anuláveis em Kotlin são tipos que podem conter tanto um valor quanto null. Eles são explicitamente indicados pelo símbolo ? após o nome do tipo.

O funcionamento baseia-se no sistema de tipos do Kotlin, que impede NullPointerException durante a compilação. O compilador exige uma verificação explícita de null antes de acessar os membros de um objeto de tipo nullable.

As principais formas de trabalhar com segurança com tipos nullable são:

Verificação de null usando if:

fun printLength(str: String?) {
    if (str != null) {
        println(str.length) // Chamada segura após verificação de null
    } else {
        println("String null")
    }
}

Operador de chamada segura (?.): Retorna null se o objeto for null, caso contrário, o resultado da chamada.
```
val safeLength: Int? = str?.length // Se str for null, safeLength será null
```
Operador Elvis (?:): Permite fornecer um valor padrão caso a expressão à esquerda do operador seja null.
```
val lengthOrDefault: Int = str?.length ?: 0 // Se str for null, lengthOrDefault será 0
```
Operador de afirmação não nula (!!): Converte um tipo nullable em não nullable. Deve ser usado com cautela, pois lançará NullPointerException se o valor for null.
```
val assertedLength: Int = str!!.length // Lançará NPE se str for null
```

Funções let/run/apply/also com chamada segura:

str?.let {
    // O código será executado somente se str não for null
    println("Comprimento da string: ${it.length}")
}

O sistema de tipos nullable do Kotlin aumenta significativamente a segurança e reduz a probabilidade de NullPointerException em comparação com linguagens onde null pode ser atribuído a qualquer tipo sem indicação explícita.

O que são tipos 'nullable' em Kotlin e como eles funcionam?