Cómo aprobar una entrevista de Kotlin: principales preguntas y respuestas

Cómo superar una entrevista de Kotlin: análisis de las preguntas principales con ejemplos

Kotlin se ha consolidado firmemente como el lenguaje moderno para el desarrollo de Android y el backend en JVM. Si te estás preparando para una entrevista técnica, es importante no solo conocer la sintaxis, sino también entender la filosofía del lenguaje: seguridad, concisión y compatibilidad con Java. En este artículo, analizaremos las preguntas clave que se hacen con más frecuencia en las entrevistas de Kotlin, con ejemplos de código reales.

1. Null Safety: cómo resuelve Kotlin el problema de null

Una de las principales ventajas de Kotlin es la protección integrada contra NullPointerException. En la entrevista, seguramente te preguntarán sobre los tipos nullable y non-null.

Pregunta: ¿Cuál es la diferencia entre String? y String? ¿Cómo trabajar de forma segura con nullable?

Respuesta: El tipo String garantiza que la variable nunca será null. String? permite null. Para el acceso seguro se utilizan los operadores ?., ?: (Elvis) y !! (solo si estás 100% seguro).

fun main() {
    val name: String? = null
    
    // Llamada segura
    println(name?.length) // null
    
    // Valor por defecto
    val length = name?.length ?: 0
    println(length) // 0
    
    // Extracción forzada (riesgo de NPE)
    // println(name!!.length) // ¡Error!
}

Pregunta adicional: ¿Qué son lateinit y lazy?

• lateinit — para variables que se inicializan más tarde (solo var).
• lazy — para inicialización delegada (solo val).

class User {
    lateinit var email: String
    
    val config by lazy { loadConfig() }
    
    fun init() {
        email = "test@example.com"
    }
}

2. Corrutinas: asincronía sin dolor

Las corrutinas (coroutines) son un must-have para el Kotlin moderno. Los entrevistadores verifican la comprensión de suspend, launch, async y los dispatchers.

Pregunta: ¿Cuál es la diferencia entre launch y async?

Respuesta: launch inicia una corrutina y devuelve un Job (sin resultado). async devuelve un Deferred, del cual se puede obtener el resultado a través de await().

suspend fun fetchData(): String {
    delay(1000)
    return "Datos cargados"
}

fun main() = runBlocking {
    // launch: sin resultado
    val job = launch {
        println("Tarea 1 completada")
    }
    
    // async: con resultado
    val deferred = async {
        fetchData()
    }
    
    println(deferred.await()) // "Datos cargados"
    job.join()
}

Pregunta: ¿Qué dispatchers (Dispatchers) conoces?

• Dispatchers.Main — para UI (Android).
• Dispatchers.IO — para entrada/salida, red.
• Dispatchers.Default — para tareas intensivas en CPU.
• Dispatchers.Unconfined — no está vinculado a un hilo específico (se usa raramente).

3. Extension functions y Sealed class: ampliando las posibilidades

Kotlin permite añadir nuevas funciones a clases existentes sin herencia. Esto se pregunta a menudo en el contexto de la arquitectura.

Pregunta: ¿Qué son las extension functions? Dé un ejemplo.

Respuesta: Son funciones que se declaran fuera de la clase, pero se invocan como sus métodos. No modifican la clase, solo añaden azúcar sintáctico.

// Extension function para String
fun String.isEmail(): Boolean {
    return this.contains("@") && this.contains(".")
}

fun main() {
    val email = "user@example.com"
    println(email.
```