Principales errores de los desarrolladores principiantes de Kotlin: de la A a la Z

Principales errores de desarrolladores principiantes en Kotlin: de la A a la Z

Kotlin es un lenguaje moderno, conciso y seguro que rápidamente se ha ganado los corazones de los desarrolladores de Android y los ingenieros de backend. Sin embargo, incluso en un lenguaje tan amigable, los principiantes suelen cometer errores típicos que ralentizan el aprendizaje y provocan bugs. En este artículo, analizaremos los problemas más comunes, desde la comprensión incorrecta de la seguridad contra nulos (null safety) hasta el abuso de lateinit. Aprenderás cómo evitarlos y escribir código limpio y eficiente en Kotlin.

1. Ignorar la seguridad contra nulos (null safety) y el manejo incorrecto de tipos anulables (nullable types)

Una de las principales ventajas de Kotlin es la protección integrada contra NullPointerException. Pero los principiantes a menudo intentan usar el enfoque de Java, lo que provoca errores.

Error: Usar !! (aserción de no nulo) donde no es necesario

Muchos escriben:

fun getUserName(user: User?): String {    return user!!.name // Si user == null — se producirá una NPE}

Es mejor usar la llamada segura (?.) o el operador Elvis (?:):

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

Error: Uso incorrecto de lateinit var

El campo lateinit está diseñado para situaciones en las que sabes con certeza que la variable se inicializará antes del primer uso (por ejemplo, en Android en onCreate). Pero si accedes a lateinit antes de la inicialización, obtendrás un UninitializedPropertyAccessException.

Consejo: Usa lateinit solo con var y verifica la propiedad ::variable.isInitialized antes de acceder.

2. Uso incorrecto de colecciones: mutables vs inmutables

Kotlin distingue claramente entre List (solo lectura) y MutableList. Los principiantes a menudo las confunden, lo que provoca errores de compilación o comportamientos inesperados.

Error: Intentar modificar una lista inmutable

val list = listOf(1, 2, 3)list.add(4) // ¡Error de compilación! listOf devuelve List, no MutableList

Si necesitas una colección mutable, usa mutableListOf:

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

Error: Devolver MutableList desde una API pública

Esto viola la encapsulación. Es mejor devolver List:

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

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

3. Abuso de companion object en lugar de funciones de nivel superior (top-level functions)

En Kotlin no hay métodos estáticos, pero existe companion object. Los principiantes a menudo ponen todo allí, aunque se pueden usar funciones o propiedades de nivel superior más concisas.

Ejemplo de error:

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

// Llamada: Utils.formatDate(...)

Es mejor mover la función al nivel de archivo:

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

// Llamada: formatDate(...)

Esto hace que el código sea más limpio y no requiere crear una clase adicional. Usa companion object solo para métodos de fábrica o constantes relacionadas con la clase.

4. Falta de comprensión de las clases selladas (sealed classes) y las expresiones when

Las clases selladas son una herramienta poderosa para representar una jerarquía de tipos limitada. Sin embargo, los principiantes a menudo olvidan la rama else o usan if-else en lugar de when, perdiendo todas las ventajas.

Error: Usar else en when para una clase sellada

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