Kotlin para Android: fundamentos de sintaxis y características

¿Qué es Kotlin?

Kotlin es un lenguaje de programación tipado estáticamente creado por JetBrains (desarrollador de IntelliJ IDEA) y lanzado en 2016 bajo la licencia Apache 2.0. Kotlin compila a bytecode JVM, JavaScript y código nativo (mediante Kotlin/Native). Sus principales áreas de aplicación son el desarrollo de Android, aplicaciones de servidor y proyectos multiplataforma.

Google anunció Kotlin como lenguaje oficial de desarrollo de Android en Google I/O 2017. Según Google (Android Developer Blog, 2026), más del 85% de los nuevos proyectos en Google Play usan Kotlin. El lenguaje también se utiliza activamente en desarrollo de servidores (Spring Boot, Ktor) y proyectos multiplataforma (Kotlin Multiplatform Mobile).

Kotlin es totalmente compatible con Java — se puede llamar código Java desde Kotlin y viceversa dentro del mismo proyecto. Las herramientas de compilación (Gradle, Maven) admiten ambos lenguajes, lo que permite migrar gradualmente de Java a Kotlin sin tiempos de inactividad.

Por qué Kotlin es más popular que Java para Android

Las razones principales: concisión — Kotlin requiere en promedio un 40% menos líneas de código que Java para la misma tarea. Null safety — el compilador prohíbe el uso de tipos nullable sin verificación. Capacidades funcionales — funciones de orden superior, lambdas, extension functions y corrutinas hacen el código más expresivo y seguro.

Fundamentos de sintaxis

La sintaxis básica de Kotlin combina concisión con claridad. Las variables se declaran mediante val (inmutable) y var (mutable). El compilador usa inferencia de tipos, pero se admite la declaración explícita de tipos. Las funciones se declaran con la palabra clave fun.

package com.example.intro

// Constantes y variables
val appName: String = "KotlinApp"  // inmutable
var version = 1.0  // mutable, tipo inferido

// Función con expression body
fun sum(a: Int, b: Int) = a + b

// String templates
fun greet(name: String) = "¡Hola, $name! Versión ${appName}_$version"

// Default and named arguments
fun createUser(
    name: String,
    age: Int = 18,
    email: String? = null
)

La expresión when reemplaza switch en Java y es más flexible: admite verificaciones de tipo, rangos, condiciones y ramas sin break. El compilador verifica la cobertura exhaustiva para enum y sealed classes. Smart casts convierten tipos automáticamente tras una verificación is, eliminando casts explícitos.

fun analyzeValue(value: Any) = when (value) {
    is String -> "Cadena de longitud ${value.length}"  // smart cast
    is Int -> "Número entero: $value"
    in 1..10 -> "Número en rango 1-10"
    else -> "Tipo desconocido"
}

Null safety y operadores Elvis

Null safety es una característica clave de Kotlin que elimina NullPointerException en tiempo de compilación. En Kotlin, los tipos no pueden ser null por defecto. Para permitir null, agregue ? al tipo: String?. El compilador exige una verificación explícita de cada valor nullable.

// Tipos nullable y non-null
val nonNull: String = "Siempre no null"
val nullable: String? = null  // permitido

// Safe call — se ejecuta solo si no es null
val length: Int? = nullable?.length

// Operador Elvis — valor por defecto
val text: String = nullable ?: "Default text"

// Let — ejecutar bloque con valor non-null
nullable?.let { value ->
    println("Valor: $value")
}

El operador safe call (?.) devuelve null si el objeto antes del operador es null, y llama al método/propiedad en caso contrario. El operador Elvis (?:) proporciona un valor predeterminado si el lado izquierdo es null. La aserción not-null (!!) lanza NullPointerException si el valor es null — úselo solo cuando esté 100% seguro de que el valor existe.

Tipos platform — tipos Java del código Java llamado que Kotlin no puede marcar como nullable o non-null. El tipo se muestra como String! (con signo de exclamación). El desarrollador es responsable de la null safety al trabajar con código Java.

Data classes y desestructuración

Las data classes en Kotlin generan automáticamente equals(), hashCode(), toString(), copy() y componentN(). Esto elimina el boilerplate de los modelos Java (POJO) y hace el código más limpio. Declarar una data class ocupa una línea en lugar de 20-30 en Java.

data class User(
    val id: Long,
    val name: String,
    val email: String,
    val age: Int? = null
)

// Uso
val user = User(1, "Ana", "anna@example.com")
val updatedUser = user.copy(age = 25)

// Desestructuración
val (id, name) = user
println("Usuario #$id: $name")

La desestructuración permite descomponer una data class en variables en una sola línea. Esto es conveniente al trabajar con pares, triplas y otros valores compuestos. La desestructuración es compatible con data classes, colecciones estándar (List, Map) y cualquier clase con operator fun componentN().

Funciones de extensión

Las extension functions son un mecanismo de Kotlin para agregar nuevos métodos a clases existentes sin herencia. Las extensiones se compilan en métodos estáticos con un parámetro receiver, por lo que no se requiere herencia ni se admite el despacho virtual.

// Función de extensión para String
fun String.isEmail(): Boolean {
    return this.contains("@") && this.contains(".")
}

// Propiedad de extensión
val String.isPhoneNumber: Boolean
    get() = this.matches(Regex("^\\+?[\\d-]{10,15}$"))

// Extensión genérica para colecciones
fun List<Int>.sumOfEvens(): Int {
    return this.filter { it % 2 == 0 }.sum()
}

// Uso
println("test@mail.com".isEmail())  // true

Las extensiones se utilizan ampliamente en Android SDK y bibliotecas. Por ejemplo, las Activity extensions en Android KTX son extension functions para Activity, Fragment, View y otras clases. Las extensiones pueden declararse como funciones de nivel superior en un archivo o como miembros de una clase.

Corrutinas para programación asíncrona

Las corrutinas son un mecanismo de programación asíncrona en Kotlin que permite escribir código no bloqueante en estilo secuencial. Una corrutina suspende su ejecución en una función suspend sin bloquear el hilo y se reanuda tras completar la operación. Es una alternativa a las cadenas de callbacks de RxJava y AsyncTask.

import kotlinx.coroutines.*

// Función suspend — puede pausarse
suspend fun fetchUserData(userId: Int): User {
    // delay — función suspend, no bloquea el hilo
    delay(500)
    return User(userId, "User $userId", "user@example.com")
}

// Iniciar en corrutina
fun loadData() {
    CoroutineScope(Dispatchers.Main).launch {
        val user = fetchUserData(1)  // pausa aquí
        updateUI(user)  // continuar en hilo Main
    }
}

Los Dispatchers determinan el pool de hilos para una corrutina: Dispatchers.Main (hilo de UI), Dispatchers.IO (operaciones de red/disco), Dispatchers.Default (tareas intensivas en CPU). La concurrencia estructurada garantiza que una corrutina no permanezca activa tras completar el scope — esto evita fugas de memoria.

// Ejecución paralela mediante async/await
suspend fun loadDashboard(): Dashboard = coroutineScope {
    val user = async { fetchUserData(1) }
    val orders = async { fetchOrders(1) }
    val stats = async { fetchStats() }
    
    Dashboard(user.await(), orders.await(), stats.await())
}

Kotlin vs Java: comparación

La elección entre Kotlin y Java para un nuevo proyecto Android es una decisión arquitectónica fundamental. Kotlin ofrece una sintaxis más moderna y mecanismos de seguridad incorporados, mientras que Java tiene un grupo más amplio de desarrolladores y bibliotecas maduras.

Rendimiento de Kotlin y Java es comparable — ambos compilan a bytecode JVM. Kotlin a veces agrega micro-sobrecarga por corrutinas e inlining, pero es insignificante para aplicaciones móviles. Google y JetBrains invierten activamente en Kotlin: Kotlin Multiplatform, Kotlin/Wasm y mejoras de rendimiento del compilador K2.