Principais erros de iniciantes em Kotlin: de A a Z

Principais Erros de Desenvolvedores Kotlin Iniciantes: De A a Z

Kotlin é uma linguagem moderna, concisa e segura que rapidamente conquistou o coração dos desenvolvedores Android e engenheiros backend. No entanto, mesmo em uma linguagem tão amigável, iniciantes frequentemente cometem erros típicos que retardam o aprendizado e geram bugs. Neste artigo, vamos detalhar os problemas mais comuns — desde a má compreensão da segurança de nulos até o uso excessivo de lateinit. Você aprenderá como evitá-los e escrever código Kotlin limpo e eficiente.

1. Ignorar a segurança de nulos e trabalho incorreto com tipos anuláveis

Uma das principais características do Kotlin é a proteção integrada contra NullPointerException. Mas iniciantes frequentemente tentam usar uma abordagem semelhante ao Java, o que leva a erros.

Erro: Usar !! (afirmação não-nula) onde não é necessário

Muitos escrevem:

fun getUserName(user: User?): String {    return user!!.name // Se user == null — receberá NPE}

É melhor usar uma chamada segura (?.) ou o operador Elvis (?:):

fun getUserName(user: User?): String {    return user?.name ?: "Convidado"}

Erro: Uso incorreto de lateinit var

O campo lateinit é destinado a situações onde você tem certeza de que a variável será inicializada antes de seu primeiro uso (por exemplo, no Android em onCreate). Mas se você acessar lateinit antes da inicialização, receberá um UninitializedPropertyAccessException.

Dica: Use lateinit apenas com var e verifique a propriedade ::variable.isInitialized antes do acesso.

2. Uso incorreto de coleções: mutável vs imutável

Kotlin separa claramente List (somente leitura) e MutableList. Iniciantes frequentemente os confundem, o que leva a erros de compilação ou comportamento inesperado.

Erro: Tentar modificar uma lista imutável

val list = listOf(1, 2, 3)list.add(4) // Erro de compilação! listOf retorna List, não MutableList

Se você precisa de uma coleção mutável, use mutableListOf:

val mutableList = mutableListOf(1, 2, 3)mutableList.add(4) // Funciona

Erro: Retornar MutableList de uma API pública

Isso quebra o encapsulamento. É melhor retornar List:

// Ruimfun getItems(): MutableList<String> = mutableListOf("a", "b")

// Bomfun getItems(): List<String> = mutableListOf("a", "b").toList()

3. Uso excessivo de companion object em vez de funções de nível superior

Kotlin não tem métodos estáticos, mas tem companion object. Iniciantes frequentemente colocam tudo lá, mesmo quando podem ser usadas funções ou propriedades de nível superior mais concisas.

Exemplo de erro:

class Utils {    companion object {        fun formatDate(date: Date): String { ... }    }}

// Chamada: Utils.formatDate(...)

É melhor mover a função para o nível do arquivo:

// arquivo: DateUtils.ktfun formatDate(date: Date): String { ... }

// Chamada: formatDate(...)

Isso torna o código mais limpo e não requer a criação de uma classe extra. Use companion object apenas para métodos de fábrica ou constantes relacionadas à classe.

4. Má compreensão de classes seladas e expressões when

Classes seladas são uma ferramenta poderosa para representar uma hierarquia de classes restrita. No entanto, iniciantes frequentemente esquecem o ramo else ou usam if-else em vez de when, perdendo todas as vantagens.

Erro: Usar else em when para uma classe selada

sealed class Result {    data class Success(val data: String) : Result()    data