Kotlin e seu Null Safety

Kotlin é uma linguagem que já esta no mercado há alguns anos, mas foi recentemente anunciada pela Google como uma das linguagens oficialmente suportadas no ambiente de desenvolvimento Android. Resultado? Um boom nas buscas segundo o Google Trends:

O que é uma NullPointerException?

Um NullPointerException é um tipo de exceção que ocorre quando um programa tenta acessar ou modificar uma propriedade ou chamar um método em um objeto que é nulo (null) em vez de um objeto válido. Isso geralmente ocorre quando o programa não verifica se um objeto é nulo antes de usá-lo, ou se uma variável foi inicializada como nula sem querer.

Um exemplo simples de como essa exceção pode ser lançada é:

String text = null;
int length = text.length;

Dessa forma a variavel ‘text’ não contém nenhum objeto e o metodo ‘length’ não funcionará, dessa forma ocorre o erro de NullPointerException.

Esse tipo de exceção é considerado particularmente perigoso porque, se não for tratado corretamente, pode causar uma falha no aplicativo.

Algumas linguagens possuem mecanismos de segurança para evitar esse tipo de exceção como o Null safety, que verifica se um valor é nulo antes de permitir que seja acessado, e acusando erro em tempo de compilação.

Como Kotlin resolve NullPointerException

Entre o pacote de motivos pelo qual Kotlin faz “a vida de um desenvolvedor Java ser mais feliz”, um dos pontos mais aclamados é como ela lida com valores nulos, ou seja, sua nullability. Embora nem tudo sejam flores, vamos entender como funciona essa mecânica e como tirar proveito dela.

Exemplos

Referências nulas e suas NullPointerExceptions (NPEs) não são coisas boas – tanto que são chamadas de The Billion Dollar Mistake. Então, para começo de conversa, o seguinte trecho de código é completamente ilegal no Kotlin:

fun main(args: Array<String>) {
    var myVar: String? = null
}

Isso acontece porque por padrão objetos não são nullables, ou em português claro e direto: não recebem null.  O mesmo acontece para argumentos de função:

fun myFunction(name: String) {
    // name nunca será null. Dentro do escopo desta função
    // não há a necessidade de checar se name == null
    println(name.length)
}

Nesse ponto você pode estar se perguntando: “mas e se eu quiser valores nulos?”. Você pode explicitamente informar que uma variável é optional (que pode ser nula) durante sua declaração usando o operador ?, como no exemplo:

fun myFunction() {
    var myVar: String? = null
}

Porém ao declarar que algo pode ser nulo, o Kotlin exige que você lide com esse objeto de maneira diferente. Você não pode operar métodos em um objeto optional como faz com os não optional. Por exemplo, isso aqui também é ilegal no Kotlin:

fun myFunction() {
    var myVar: String? = null
}

Sempre que precisar acessar métodos em um objeto opcional, use o operador ? antes do método, como no exemplo:

fun myFunction() {
    var myVar: String? = null
    var myVarLength: Int? = myVar?.length
}

Como você pode perceber, eu não posso receber diretamente o retorno de uma operação realizada em um objeto opcional em objeto não opcional – por isso a variável myVarLength também precisa ser opcional. O Kotlin provê o operador ?:  para declarar rapidamente um valor padrão caso o objeto esteja nulo:

fun myFunction() {
    var myVar: String? = null
    // Nesse caso, myVarLength será zero.
    var myVarLength: Int = myVar?.length ?: 0
}

Se você tiver que lidar com objetos optionals, o Kotlin permite através do seu Smart Cast um atalho para que você não tenha que ficar usando o operador ? em toda linha: caso seu bloco de código assegure que um objeto não é nulo, você não precisa usar o operador ?. Exemplo:

fun myFunction() {
    var myVar: String? = "Hello, World!"
    if (myVar != null) {
        println(myVar.length)
    }
}

Optionals do Kotlin e a tal interoperabilidade com códigos Java

Como lidar no Kotlin ao usar códigos Java, já que Java permite valores nulos em quase tudo? A equipe do Kotlin fez um belo trabalho se preocupando em tratar códigos importados do Java de maneira mais “relaxada”, criando uma categoria especial de tipos chamada platform types. Você não pode criar manualmente objetos com esse tipo, mas eles estão lá sempre que usamos códigos Java.

Com isso, você não precisa ficar usando o operador ? sempre que precisar acessar o objeto. A parte ruim é que neste caso você precisa tomar cuidado com NPEs em runtime, fazendo null check sempre que preciso.

Conclusão

Null safety é só um de muitos outros aspectos positivos da linguagem. Se você já esta usando, deixa ai nos comentários o que tem agradado (ou não). Até a próxima!