Explique o que é a segurança nula na linguagem…

A segurança nula — é uma funcionalidade da linguagem Kotlin que impede erros relacionados com referências null. É alcançada criando dois tipos de referências: nullable (que permite null) e non-nullable (que não permite null).

Os tipos non-nullable são declarados normalmente:

var nonNullableString: String = "Hello" // Não pode ser null

Os tipos nullable são declarados usando o símbolo ? após o nome do tipo:

var nullableString: String? = "Hello" // Pode ser null
nullableString = null

O Kotlin exige um tratamento explícito de tipos nullable, evitando o acesso direto aos seus membros sem uma verificação prévia de null. Para isso, fornece os seguintes mecanismos:

Operador de chamada segura (?.): Invoca um método ou acessa uma propriedade apenas se o objeto não for null. Caso contrário, retorna null.
```
val length = nullableString?.length // length será Int? ou null
```

Operador Elvis (?:): Fornece um valor padrão se a expressão à esquerda do operador for null.

val nonNullLength = nullableString?.length ?: 0 // nonNullLength será Int, 0 se nullableString for null

Operador de afirmação de não-null (!!): Converte um tipo nullable em não-nullable. Se o valor for null, lança uma exceção NullPointerException. Usado quando o programador tem certeza de que o valor não é null.
```
val sureLength = nullableString!!.length // Lançará NullPointerException se nullableString for null
```
Verificações com if: Verificação tradicional de null usando if. O compilador realiza um smart cast (conversão inteligente) do tipo nullable para não-nullable dentro do bloco if, se a verificação passar.
```
if (nullableString != null) {
    val length = nullableString.length // Aqui nullableString é tratado como String
}
```

Estes mecanismos permitem gerenciar explicitamente as situações em que uma variável pode ser null, reduzindo significativamente a probabilidade de NullPointerException em tempo de execução.

Explique o que é a segurança nula na linguagem Kotlin.