Saltar a contenido

Tema 2.1 - Fundamentos del lenguaje Kotlin

Kotlin es el lenguaje recomendado por Google para Android. Aquí aprendes sus fundamentos ejecutando código de verdad: los 14 bloques Código N son escenas de una app real (FumetoPMDM) y cada captura muestra la salida que Kotlin imprimió.

Materiales: Sintaxis completa

🟢 Leyenda de repaso obligatorio: los textos con este fondo verde son imprescindibles: hay que repasarlos cada semana, porque entrarán en todas las evaluaciones del módulo.
Código Descripción
RA 2 Desarrolla aplicaciones para dispositivos móviles analizando y empleando las tecnologías y librerías específicas.
CE a) Se ha generado la estructura de clases necesaria para la aplicación.

Este tema da el lenguaje con el que se genera esa estructura: tipos, funciones, colecciones, enums, clases y data classes.

0. Por qué Kotlin

Kotlin es un lenguaje de propósito general, multiplataforma, tipado estáticamente y compilado (a bytecode JVM). Desde 2017 es el lenguaje preferente de Google para Android.

  • Sintaxis concisa y expresiva: menos código repetitivo; un data class de una línea genera equals, toString y copy.
  • Seguridad de tipos: la nulabilidad se declara en el tipo (String?), lo que elimina de raíz el NullPointerException sorpresa.
  • Interoperable con Java: usa sin problema las librerías existentes de Android.
  • Inferencia de tipos: el tipo se escribe cuando aporta información.
  • Enfoque moderno: funciones de orden superior, lambdas y operaciones funcionales sobre colecciones (filter, map...).

Cómo funciona esta lección: los 14 bloques Código N son exactamente las funciones de la app de escenas FumetoPMDM (am start --ei codigo N). Cada escena va envuelta en un arnés que redirige System.out para pintar los println en pantalla:

// Arnés de laboratorio: ejecuta el bloque capturando su stdout.
fun consola(bloque: () -> Unit): List<String> {
    val buf = ByteArrayOutputStream()               // Buffer donde irá a parar el stdout
    val viejo = System.out                          // Guardamos el stdout original
    System.setOut(PrintStream(buf))                 // Redirigimos System.out al buffer
    bloque()                                        // EJECUTAMOS el código didáctico
    System.setOut(viejo)                            // Restauramos el stdout
    return String(buf.toByteArray()).lines().filter { it.isNotBlank() }
}

1. Estructura de un programa Kotlin

Un programa Kotlin es una sucesión de sentencias, una por línea (el punto y coma es opcional). Arranca siempre en main().

fun main() {                 // punto de entrada del programa
    println("Hola, mundo")   // imprime una línea en la salida estándar
}
Elemento Descripción
Palabras clave Palabras especiales del lenguaje: val, fun, if
Identificadores Nombres de variables, funciones, clases...
Literales Valores fijos: 1.3, true, "Hola"
Operadores +, ==, &&...
Comentarios Notas que el compilador ignora

El código se ejecuta en Android Studio (proyecto o Scratch) o en el Playground online (https://play.kotlinlang.org/).

// Comentario de una sola línea
/* Comentario de
   bloque */
/** Comentario de documentación (KDoc). */

Comenta el porqué, no el qué

// precio con IVA aporta más que // suma 21%.

2. Variables y constantes: var y val

Regla de oro Kotlin: declara todo con val y solo cambia a var cuando demuestres que necesitas reasignar. El compilador te avisa si te pasas.
val var
Palabra del lenguaje value variable
Cambiables tras la asignación No Sí
Uso Por defecto, siempre que puedas Acumuladores, bucles, estado
val msg: String = "Hello, World"  // inmutable
var count: Int = 0                // mutable
count += 1                        // var: se puede reasignar
val x = 10                        // inferencia: el compilador deduce Int
val y = 10.2                      // Double inferido

val impide reasignar, no mutar

val lista = mutableListOf(1) deja hacer lista.add(2): la referencia no se mueve, el contenido sí. Se pregunta mucho en el examen.

Lo inmutable da menos errores, más legibilidad y más seguridad en concurrencia.

📺 Escena — Código 1 (función esc01 exacta de la app):

fun esc01(): List<String> = consola {
    // Un programa Kotlin arranca en main(); aquí simulamos ese cuerpo.
    println("Hola, Kotlin")                        // salida estándar
    val pi = 3.14                                 // val: inmutable, Double inferido
    var contador: Int = 0                         // var: mutable, tipo anotado
    contador += 1                                 // los var sí se reasignan
    println("pi=$pi   contador=$contador")
    // En Kotlin no hace falta punto y coma al final de línea
    println("regla de oro: val por defecto; var solo si hace falta")
}

Captura de la app de escenas: el Código 1 ejecutándose en el emulador

Imprime Hola, Kotlin, luego pi=3.14 contador=1 (el += 1 mutó el var). $pi es un string template (Sección 6).

3. Null-safety: el fin del NullPointerException

El sistema de tipos distingue String (nunca null) de String? (nullable): si una función puede devolver null, está obligada a decirlo en su firma, y el compilador no te deja usar el resultado sin manejarlo.

val m: String? = null
println(m?.length ?: 0)                  // → 0  (nunca llega a romper)
Operador Nombre Qué hace
?. safe call Aplica el acceso solo si no es null; si no, toda la expresión vale null
?: Elvis Valor de reserva cuando la parte izquierda es null
!! aserción nula "Apuesto a que no es null" — si pierdes la apuesta, NPE

📺 Escena — Código 2 (función esc02 + auxiliar, exactas):

fun puedeSerNulo(caso: Int): String? = if (caso % 2 == 0) "par" else null

fun esc02(): List<String> = consola {
    val s: String? = puedeSerNulo(3)              // String? admite null
    val len = s?.length ?: 0                      // safe call + elvis: si null, 0
    println("s=$s  →  s?.length ?: 0  da $len")
    val t: String? = puedeSerNulo(4)              // ahora sí trae valor
    println("t=$t  →  longitud ${t?.length ?: 0}")
    val forzado = t!!                             // !! afirma que no es null (NPE si miente)
    println("con !! (sabiendo que t no es null): \"$forzado\"")
    println("Java usaba ternarios y NPEs sorpresa; Kotlin lo declara en el tipo")
}

Captura: safe call, Elvis y !! en acción

Con caso=3 la función devuelve null: s?.length no se ejecuta y Elvis da 0. Con caso=4, t vale "par" y el !! es seguro.

4. Tipos básicos

Todos los tipos son objetos y las conversiones numéricas son explícitas: no hay conversión implícita.

Tipo Tamaño Rango
Long 64 bits -2⁶³ … 2⁶³-1
Int 32 bits -2³¹ … 2³¹-1
Short 16 bits -32768 … 32767
Byte 8 bits -128 … 127
Double 64 bits (IEEE 754) ±4.9e-324 … ±1.7e+308
Float 32 bits (IEEE 754) ±1.4e-45 … ±3.4e+38
Char 16 bits cualquier carácter Unicode
Boolean 8 bits true / false
String — secuencia inmutable de caracteres
val maximo: Int = Int.MAX_VALUE       // 2147483647
val minimo: Int = Int.MIN_VALUE       // -2147483648
val grande: Long = 150_000_000_000    // sufijo implícito por el tipo; guiones bajos legibles
val pi = 3.14159                      // Double inferido
val letra: Char = 'A'                 // ¡comilla simple! "A" sería String
val ok: Boolean = true

5. Operadores

== compara contenidos; para comparar referencias se usa ===.

Tipo Operadores
Aritméticos + - * / %
Relacionales < <= > >= == != ===
Lógicos && \|\| !

Precedencia (de mayor a menor):

Precedencia Operadores
Mayor ( )
x++ x--
+x -x ++x --x !
* / %
+ -
<< >> >>>
.. ..< ..=
is as
> >= < <=
in !in
Menor == != === !==

📺 Escena — Código 3 (función esc03 exacta):

fun esc03(): List<String> = consola {
    val a = 10                                    // Int inferido
    val b = 3
    val ratio = a.toDouble() / b                  // conversión EXPLÍCITA: sin ella, 3
    println("10/3 entero=3, pero toDouble()/3 = $ratio")
    var x = 5
    x++                                           // incremento postfijo
    val ok = (10 % 3 == 1) && (2 * 2 == 4)        // % resto, && lógico
    println("x tras x++ → $x     ok=$ok")
    val n: Long = 7
    val d = n.toFloat()                           // sin coerción implícita: toFloat()
    println("Long $n → Float $d (Kotlin NO convierte tipos sin preguntar)")
    val dos: Int = 'A'.code                       // Char → su código
    println("'A'.code = $dos   y comparar == compara CONTENIDO, no referencia")
}

Captura: operadores, conversiones explícitas y == de contenido

6. Cadenas de caracteres

Las String son inmutables: cada operación devuelve una cadena nueva. La interpolación $variable y ${expresión} evita concatenar con +.

val nombre = "Ana"
val s = "Hola, $nombre. Dentro de un año: ${2026 + 1}"   // templates

val multilinea = """
    Multilínea "literal"
    sin escapar comillas
""".trimIndent()                               // raw string + reindentado
Método Qué devuelve
length Longitud de la cadena
get(i) / [i] Carácter en la posición i
substring(i, j) Subcadena de i a j (sin incluir j)
uppercase() / lowercase() Copia en mayúsculas / minúsculas
trim() Copia sin espacios de borde
split(delim) Lista de trozos al partir por delimitador
replace(a, b) Copia con a sustituido por b
contains(s) / in true si la contiene
isEmpty() / isBlank() Vacía / vacía o solo espacios
startsWith(s) / endsWith(s) Prefijo / sufijo
indexOf(s) / lastIndexOf(s) Primera / última posición

📺 Escena — Código 4 (función esc04 exacta):

fun esc04(): List<String> = consola {
    val nombre = "Ana"
    println("Hola, $nombre. Año que viene: ${2026 + 1}")      // interpolación + expresión
    val s = " Kotlin "
    val t = s.trim().uppercase()                              // las String son inmutables: devuelven nuevas
    println("""trim().uppercase() → "$t"""")
    val ok = "ko" in t.lowercase()                            // in = contains, case-sensitive
    println("\"ko\" en \"${t.lowercase()}\" → $ok")
    val sub = "Kotlin".substring(0, 3)                        // subcadena [0,3)
    println("substring(0,3) → \"$sub\"")
    val partes = "uno;dos;tres".split(";")                    // partir
    println("split(\";\") → ${partes.joinToString(" | ")}")   // unir con joinToString
    println("isBlank() en \"   \" → ${"   ".isBlank()}   isEmpty() en \"\" → ${"".isEmpty()}")
    val multi = """
        Multilínea "literal"
        sin escapar comillas
    """.trimIndent()
    println("raw string con ${multi.lines().size} líneas")
}

Captura: string templates, catálogo de métodos de texto

7. Funciones

Sintaxis mínima: fun nombre(param: Tipo): Retorno = expresión.

fun suma(a: Int, b: Int): Int = a + b           // cuerpo-expresión: return implícito
fun maxDe(a: Int, b: Int) = if (a > b) a else b // el tipo de retorno se infiere
fun despedirse() = println("Adiós")             // devuelve Unit (≈ void)

Parámetros con nombre (en cualquier orden) y por defecto:

fun saludar(nombre: String, titulo: String = "Sr./Sra.") = println("Hola, $titulo $nombre")
saludar("Ana")                                  // usa el default
saludar(nombre = "Ana", titulo = "Dra.")        // nombrados: el orden da igual

vararg admite N argumentos del mismo tipo, y las funciones pueden anidarse:

fun media(vararg notas: Double) = notas.average()
fun procesar(nums: List<Int>): Int {
    fun esPar(n: Int) = n % 2 == 0              // función local
    return nums.filter(::esPar).sum()
}

📺 Escena — Código 5 (las cuatro funciones anteriores + esc05, todas exactas):

fun suma(a: Int, b: Int): Int = a + b             // cuerpo-expresión, sin return

fun sumaConReturn(a: Int, b: Int): Int { return a + b }  // forma clásica, equivalente

fun media(vararg notas: Double) = notas.average() // vararg: N argumentos

fun <T> primero(lista: List<T>): T? = lista.firstOrNull()   // genérica

fun procesar(nums: List<Int>): Int {              // local function
    fun esPar(n: Int) = n % 2 == 0                //   solo visible aquí dentro
    return nums.filter(::esPar).sum()
}

fun saludar(nombre: String, titulo: String = "Sr./Sra.") =
    println("Hola, $titulo $nombre")              // parámetro por defecto

fun esc05(): List<String> = consola {
    println("suma(2,3) = ${suma(2, 3)}   sumaConReturn(2,3) = ${sumaConReturn(2, 3)}")
    println("media(1.0, 2.0, 3.0) = ${media(1.0, 2.0, 3.0)}")
    println("primero(listOf(7,9)) = ${primero(listOf(7, 9))}   primero(vacía) = ${primero(emptyList<Int>())}")
    println("procesar([1..6]) = ${procesar(listOf(1, 2, 3, 4, 5, 6))}   ← usó la función local esPar")
    saludar("Ana")                                // usa el valor por defecto
    saludar(nombre = "Ana", titulo = "Dra.")      // argumentos NOMBREADOS (orden libre)
    saludar(titulo = "Dr.", nombre = "Luis")
}

Captura: funciones con default, vararg, genéricos y locales

7.1. Funciones de orden superior y lambdas

Una función de orden superior (HOF) toma otra función como parámetro o la devuelve.

fun aplicaDosVeces(x: Int, f: (Int) -> Int): Int = f(f(x))   // f es un parámetro-FUNCIÓN

Una lambda es una función anónima: { parámetros -> cuerpo }. Con un único parámetro se llama it, y si el último parámetro es una lambda, puede ir fuera de los paréntesis (trailing):

val cuadrado = { n: Int -> n * n }
aplicaDosVeces(2, cuadrado)          // 16: cuadrado(cuadrado(2))
aplicaDosVeces(3) { it + 1 }         // 5:  trailing lambda + it implícito

Una referencia (::nombre) usa una función nombrada donde se espera una lambda:

val pares = listOf(1, 2, 3, 4).filter(::esPar)   // idéntico a filter { esPar(it) }, más directo

Los tipos de función se escriben (Entrada) -> Salida: (Int) -> Int, (String, String) -> Boolean, () -> Unit.

📺 Escena — Código 6 (función esc06 + auxiliares, exactas):

fun aplicaDosVeces(x: Int, f: (Int) -> Int): Int = f(f(x))   // HOF: recibe una función

fun esParNum(n: Int) = n % 2 == 0

fun esc06(): List<String> = consola {
    val cuadrado = { n: Int -> n * n }            // lambda con parámetro tipado
    println("aplicaDosVeces(2, cuadrado) = ${aplicaDosVeces(2, cuadrado)}   ← (2²)² = 16")
    println("aplicaDosVeces(3) { it + 1 } = ${aplicaDosVeces(3) { it + 1 }}   ← trailing lambda + it")
    val nums = listOf(1, 2, 3, 4)
    println("nums.filter(::esParNum) = ${nums.filter(::esParNum)}   ← referencia a función")
    val transformador: (Int) -> String = { n -> "n=$n" }      // una función es un VALOR
    println("lambda en variable: ${transformador(42)}")
    println("tipos de función: (Int) -> Int · (String, String) -> Boolean · () -> Unit")
}

Captura: HOF, trailing lambdas, it y referencias

8. Estructuras de control

if / else: es una expresión

En Kotlin if devuelve un valor:

val mayor = if (a > b) a else b      // if como expresión: asignable

when

Se ejecuta el primer caso que coincida; los when que devuelven valor obligan a else, y si el sujeto es un enum no hace falta porque el compilador comprueba que los cubres todos:

val mensaje = when (opcion) {
    1, 2 -> "baja"                  // varios valores por rama
    in 3..10 -> "media"             // rangos
    !in 10..20 -> "alta"            // y negaciones
    else -> "invalid option"
}
when {                              // sin sujeto: condiciones arbitrarias
    x !is Int    -> println("no es Int")
    x == 5       -> println("smart cast: aquí x ya es Int sin casteos")
}

Bucles

for recorre rangos (a..b inclusivo, a until b exclusivo, downTo, step) e iterables; withIndex da posición y valor; while y do-while llevan break y continue:

for (i in 1..5) { }                 // 1 2 3 4 5
for (i in 10 downTo 0 step 2) { }   // 10 8 6 4 2 0
for ((i, v) in lista.withIndex()) { }
while (x < 3) { }
do { } while (x < 3)

📺 Escena — Código 7 (función esc07 exacta):

fun esc07(): List<String> = consola {
    val a = 7; val b = 9
    val mayor = if (a > b) a else b               // if como EXPRESIÓN que devuelve valor
    println("if expresión: mayor de $a y $b → $mayor")
    val op = 2
    val mensaje = when (op) {                     // when: el primer caso que encaja gana
        1 -> "Alta"; 2 -> "Baja"; 3 -> "Consulta"
        else -> "opción inválida"
    }
    println("when(op=$op) → $mensaje")
    val x = 5
    val y: Any = "hola"
    when {                                        // when sin sujeto: rangos y smart cast
        x in 1..10 -> println("when: $x está en 1..10")
        y is String -> println("smart cast: kotlin lo trata como String, len=${y.length}")
        else -> println("otro caso")
    }
    var suma = 0
    for (i in 1..5) suma += i                     // rango inclusivo
    println("for 1..5 → suma=$suma")
    println("for 10 downTo 0 step 2 → " + (10 downTo 0 step 2).joinToString(","))
    val items = listOf("a", "b", "c")
    println("withIndex → " + items.withIndex().joinToString { (i, v) -> "$i→$v" })
    var k = 0
    while (k < 3) k++                             // while/do-while/break/continue: como en Java
    println("while → k=$k")
}

Captura: when exhaustivo, rangos, withIndex y smart cast

9. Practica: mini-testing con require()

require(condición) { "mensaje" } lanza IllegalArgumentException si la condición falla: sirve para autoverificar un ejercicio sin un framework de tests.

📺 Escena — Código 8 (funciones esc08 + auxiliares, exactas):

fun cuadrado(n: Int) = n * n

fun areaTriangulo(base: Double, altura: Double): Double {
    require(base > 0 && altura > 0) { "base y altura deben ser positivas" }  // precondición
    return base * altura / 2
}

fun esc08(): List<String> = consola {
    require(cuadrado(3) == 9) { "3² debe ser 9" } // si falla: IllegalArgumentException
    println("require pasado: cuadrado(3)=${cuadrado(3)}")
    try {
        areaTriangulo(-2.0, 3.0)                  // precondición rota a propósito
    } catch (e: IllegalArgumentException) {
        println("require lanza IllegalArgumentException: ${e.message}")
    }
    println("Tests OK  ← así se autoverifica un ejercicio sin framework")
}

Captura: require como mini framework de tests

El try/catch demuestra que el mecanismo de fallo funciona. Bonus: escribid vuestro propio assertEquals y sustituid con él los require.

10. Arrays

Un Array<T> es una colección ordenada de tamaño fijo y contenido mutable. Las variantes primitivas (IntArray, CharArray...) evitan el boxing.

val a = arrayOf(1, 2, 3)              // Array<Int>
val b = Array(3) { i -> i * 2 }       // [0, 2, 4] — inicializado por lambda
val c = IntArray(3) { it * 2 }        // variante primitiva: más ligera
a[0] = 10                             // contenido mutable; el tamaño, no
val matriz = Array(3) { IntArray(3) } // arrays de arrays (matrices)
Operación Array List
Cambiar tamaño ✗ ✓
Cambiar contenido ✓ en MutableList, ✓
contentToString() / toString() contentToString() (o sale el hash) toString() pinta [1, 2, 3]

📺 Escena — Código 9 (función esc09 exacta):

fun esc09(): List<String> = consola {
    val a = arrayOf(1, 2, 3)                      // Array<Int>: tamaño FIJO, contenido mutable
    a[0] = 10
    println("arrayOf → ${a.contentToString()} (a[0]=10)  → a.toList() = ${a.toList()}")
    val b = IntArray(3) { it * 2 }                // primitivo especializado, sin boxing
    println("IntArray(3) { it*2 } = ${b.contentToString()}")
    val nums = listOf(5, 2, 8, 2)                 // colección inmutable
    val paresOrdenados = nums.filter { it % 2 == 0 }.sorted()   // funcional: NO muta
    println("filter+sorted → $paresOrdenados   original intacto: $nums")
    println("inmutables: List/Set/Map · mutables: MutableList/MutableSet/MutableMap")
}

Captura: arrays y la diferencia inmutable/mutable

11. Colecciones: el mapa mental

Kotlin divide las colecciones en inmutables (solo lectura) y mutables (con operaciones de cambio):

Interfaz Qué es Crear Mutar
List<T> Ordenada, duplicados permitidos listOf(...), List(5){...} add set removeAt clear (Mutable)
Set<T> Sin duplicados setOf(...), sortedSetOf(...) add remove clear (Mutable)
Map<K,V> Pares clave→valor mapOf("a" to 1), toMap() put set remove clear (Mutable)

Sobre cualquiera funcionan las operaciones funcionales, que devuelven resultados nuevos: filter, map, sorted, distinct, any/all, sum/max, slice, chunked, partition...

El error de concepto nº1 del tema

filter no elimina elementos: devuelve otra lista. Y sortedBy (copia nueva) no es sortBy (en sitio, solo mutable).

12. Listas

  • Crear: listOf(1,2,3) · mutableListOf(...) · List(5) { it*it } · (1..5).toList().
  • Acceder: size, first()/last() (y firstOrNull que no falla), xs[2], getOrNull(9), slice(1..2), take(2).
  • Mutar (solo MutableList): add(4), removeAt(0), xs[0] = 100, remove(2), clear().
  • Transformar: filter, map, filterNotNull (la nulabilidad tiene dos niveles: la lista y sus elementos), distinct, flatten, sorted, zip.
  • Consultar: any/all, find, count, sum/average/max.
  • Convertir: toSet(), toMutableList(), toIntArray().

📺 Escena — Código 10 (función esc10 exacta):

fun esc10(): List<String> = consola {
    println("List(5){it*it} → ${List(5) { it * it }}   (1..5).toList() → ${(1..5).toList()}")
    val xs = listOf(10, 20, 30, 40)
    println("size=${xs.size} first=${xs.first()} xs[2]=${xs[2]} slice(1..2)=${xs.slice(1..2)}")
    println("firstOrNull en vacía → ${emptyList<Int>().firstOrNull()} (first lanzaría)")
    val ms = mutableListOf(1, 2, 3)               // MutableList: sí se modifica
    ms.add(99); ms.removeAt(0); ms[0] = 100
    println("mutable add/removeAt/[0]=100 → $ms")
    println("sin mutar: listOf(1,2)+3 → ${listOf(1, 2) + 3} · listOf(1,2,2)-2 → ${listOf(1, 2, 2) - 2}")
    val ns = listOf(1, 2, 3, 4, 5)
    println("map x2 → ${ns.map { it * 2 }}   filter pares → ${ns.filter { it % 2 == 0 }}")
    println("distinct → ${listOf(1, 2, 2, 3).distinct()}   flatten → ${listOf(listOf(1, 2), listOf(3)).flatten()}")
    println("sorted → ${listOf(5, 3, 9, 1).sorted()}   any>4 → ${ns.any { it > 4 }}   find>3 → ${ns.find { it > 3 }}")
    val conNulos: List<Int?> = listOf(1, null, 3) // nullabilidad en DOS niveles
    println("List<Int?> $conNulos → filterNotNull → ${conNulos.filterNotNull()}")
    println("convertir: toSet() → ${listOf(1, 2, 2).toSet()}   toIntArray() OK")
}

Captura: tour completo de listas

13. Mapas

Colecciones de pares clave→valor. Las claves son únicas; pedir una clave inexistente con corchetes devuelve null (no excepción) en los mapas inmutables, y getOrDefault/getOrElse te dan la vía cortés. mapOf conserva el orden de inserción.

val precios = mapOf("pan" to 1.2, "leche" to 1.1)   // inmutable: NO se puede put
val m = mutableMapOf("pan" to 1.2)                  // mutable
m["leche"] = 1.1                                    // añadir/actualizar con corchetes
val p: Double? = m["huevos"]                        // clave desconocida → null
val par = listOf("A", "B").zip(listOf(1, 2)).toMap()  // construir desde listas
for ((k, v) in m) { }                               // desestructuración al iterar

📺 Escena — Código 11 (función esc11 exacta):

fun esc11(): List<String> = consola {
    val precios = mutableMapOf("pan" to 1.2, "leche" to 1.1)
    precios["leche"] = 1.25                       // actualizar con corchetes
    println("mutableMapOf → $precios")
    println("\"huevos\" in precios → ${"huevos" in precios}   containsKey(pan) → ${precios.containsKey("pan")}")
    val x1: Double? = precios["huevos"]           // clave inexistente → null, NO excepción
    println("m[clave inexistente] → $x1   getOrDefault → ${precios.getOrDefault("huevos", 0.0)}")
    println("getOrElse (cálculo diferido) → ${precios.getOrElse("huevos") { 0.0 * 99 }}")
    println("total = values.sum() → ${precios.values.sum()}")
    val mZip = listOf("A", "B", "C").zip(listOf(1, 2, 3)).toMap()
    println("zip().toMap() → $mZip")
    for ((k, v) in precios) println("destructuring: $k ⇒ $v")
    println("mapOf devuelve LinkedHashMap: conserva el ORDEN de inserción")
}

Captura: mapas, claves desconocidas e iteración

14. Enumeraciones

Un enum class define un conjunto cerrado de constantes con nombre (estados, roles, tipos). Cada constante puede llevar propiedades y funciones.

enum class Rol { ADMIN, EDITOR, LECTOR }              // simple

enum class Nivel(val prioridad: Int) {                // con datos
    BAJO(1), MEDIO(2), ALTO(3);                       // el punto y coma abre el cuerpo
    fun esCritico() = this == ALTO
}
println(Nivel.ALTO.name)        // "ALTO"   (nombre)
println(Nivel.ALTO.ordinal)     // 2        (posición)
Nivel.entries                   // todas las constantes (sustituye al values() clásico)

📺 Escena — Código 12 (función esc12 + enums, exactas):

enum class Rol { ADMIN, EDITOR, LECTOR }

enum class Nivel(val prioridad: Int) {            // enum con propiedad y función
    BAJO(1), MEDIO(2), ALTO(3);                   //  el punto y coma abre el cuerpo
    fun esCritico() = this == ALTO
}

fun esc12(): List<String> = consola {
    val r = Rol.ADMIN
    println("role=$r  name=\"${r.name}\"  ordinal=${r.ordinal}")
    println("Nivel.ALTO.prioridad=${Nivel.ALTO.prioridad}   esCritico()=${Nivel.ALTO.esCritico()}")
    println("todas las constantes: ${Nivel.entries.joinToString { "${it.name}(${it.prioridad})" }}")
    val permiso = when (r) {                      // when EXHAUSTIVO sobre enum: sin else
        Rol.ADMIN -> "puede todo"
        Rol.EDITOR -> "escribir"
        Rol.LECTOR -> "solo leer"
    }
    println("when sobre enum (sin else): ADMIN → $permiso")
    println("cada constante es un singleton: útil para estados, roles y tipos cerrados")
}

Captura: enums con prioridad, name/ordinal y when exhaustivo

15. Programación orientada a objetos

Un objeto = estado (propiedades) + comportamiento (métodos); una clase = su plano de fabricación. Es la base de la estructura de clases de cualquier app (CE a).

class Usuario(val id: Int, var nombre: String)    // el constructor primario DECLARA propiedades

init para validar y constructor secundario que delega en el primario:

class Producto(val id: Int, val nombre: String, var precio: Double) {
    init { require(precio >= 0) { "Precio negativo" } }             // validación al construir
    constructor(id: Int, nombre: String) : this(id, nombre, 0.0)   // secundario → this(...)
}

Propiedades calculadas con get(), que se evalúan en cada lectura:

class Rectangulo(var ancho: Int, var alto: Int) {
    val area: Int get() = ancho * alto            // calculada al leerla, no cacheada
    fun escalar(k: Int) { ancho *= k; alto *= k }
}

Las data classes generan equals, hashCode, toString, copy y desestructuración: comparan contenidos, no referencias.

class PersonaNormal(val nombre: String, var edad: Int)
data class Persona(val nombre: String, var edad: Int)   // genera equals, toString, copy...

val a = Persona("Ana", 30); val b = Persona("Ana", 30)
a == b                    // true  (equals estructural)
val c = a.copy(edad = 31) // copia cambiando solo un campo
val (n, e) = a            // desestructuración vía component1/component2

Herencia: en Kotlin todo es final y no heredable por defecto; hay que marcar open en la base y override en la derivada. Las interface se implementan con la misma sintaxis:

open class Animal(open val nombre: String) { open fun sonido() = "..." }
class Perro(override val nombre: String) : Animal(nombre) {     // : = "hereda de"
    override fun sonido() = "guau"
}
interface Volador { fun volar(): String }
class Pajaro(override val nombre: String) : Animal(nombre), Volador {
    override fun volar() = "aleteo"
}

📺 Escena — Código 13 (todas las clases anteriores + esc13, exactas):

class Usuario(val id: Int, var nombre: String)    // constructor primario en la cabecera

class Producto(val id: Int, val nombre: String, var precio: Double) {
    init { require(precio >= 0) { "Precio negativo" } }        // bloque de validación
    constructor(id: Int, nombre: String) : this(id, nombre, 0.0)  // secundario → delega
}

class Rectangulo(var ancho: Int, var alto: Int) {
    val area: Int get() = ancho * alto            // propiedad CALCULADA
    fun escalar(k: Int) { ancho *= k; alto *= k } // método miembro
}

class PersonaNormal(val nombre: String, var edad: Int)          // clase al uso

data class Persona(val nombre: String, var edad: Int)           // data: añade mucho gratis

open class Animal(open val nombre: String) { open fun sonido() = "..." }

class Perro(override val nombre: String) : Animal(nombre) {     // herencia: open/override
    override fun sonido() = "guau"
}

interface Volador { fun volar(): String }

class Pajaro(override val nombre: String) : Animal(nombre), Volador {
    override fun volar() = "aleteo"
}

fun esc13(): List<String> = consola {
    val u = Usuario(1, "Ana")
    u.nombre = "Ana María"                        // var sí, val no
    println("Usuario → ${u.nombre} (val id inmutable, var nombre editable)")
    val p = Producto(1, "Teclado")                // usa el constructor secundario
    println("secundario delega en primario: precio=${p.precio}")
    val r = Rectangulo(2, 3); r.escalar(2)
    println("Rectangulo(2,3).escalar(2) → area=${r.area}  (get() calcula al leer)")
    val a1 = PersonaNormal("Ana", 30); val a2 = PersonaNormal("Ana", 30)
    println("class normal: a == b → ${a1 == a2}   toString → ${a1.javaClass.simpleName}@${a1.hashCode().toString(16)}")
    val b1 = Persona("Ana", 30); val b2 = Persona("Ana", 30)
    println("data class: b == b → ${b1 == b2}   toString → $b1")
    val copia = b1.copy(edad = 31)                // copia cambiando un campo
    val (n, e) = b1                               // desestructuración por componentN()
    println("copy(edad=31) → $copia   y (n,e) → $n, $e")
    println("herencia: Perro → ${Perro("Luna").sonido()}   Pajaro → ${Pajaro("Pio").sonido()}/${Pajaro("Pio").volar()}")
    println("Kotlin es final por defecto: hereda solo de open/abstract")
}

Captura: POO completa — init, get(), data class y herencia

16. Colecciones de objetos: el CRUD completo

Una data class como modelo y una MutableList como almacén, con las consultas funcionales del tema.

📺 Escena — Código 14 (función esc14 + modelo, exactas):

data class Libro(val id: Int, val titulo: String, val paginas: Int, val autor: String)

fun esc14(): List<String> = consola {
    val libros = mutableListOf(
        Libro(1, "Kotlin 101", 180, "Ana"),
        Libro(2, "Compose", 220, "Luis"),
    )
    libros += Libro(3, "Coroutines", 200, "Ana")  // += en mutableList
    libros[0] = libros[0].copy(paginas = 190)     // data class: copiar corregida
    println("${libros.size} libros · el 1º con ${libros[0].paginas} págs (tras copy)")
    println("filtrar por autor → ${libros.filter { it.autor == "Ana" }.map { it.titulo }}")
    println("primero >200 págs → ${libros.firstOrNull { it.paginas > 200 }?.titulo}")
    println("any con Compose → ${libros.any { it.titulo.contains("Compose") }}")
    println("indexOfFirst Coroutines → ${libros.indexOfFirst { it.titulo == "Coroutines" }} (o -1)")
    println("sortedBy págs → ${libros.sortedBy { it.paginas }.joinToString { it.titulo }}")
    val orden = libros.sortedWith(compareBy<Libro> { it.autor }.thenBy { it.titulo })
    println("autor↑ título↑ → ${orden.joinToString { "${it.autor}:${it.titulo}" }}")
    libros.sortByDescending { it.paginas }        // en sitio (solo MutableList)
    println("sortByDescending en sitio → ${libros.joinToString { it.titulo }}")
    println("total páginas → ${libros.sumOf { it.paginas }}")
}

Captura: CRUD y consultas sobre una colección de data classes

El patrón filter → map → joinToString (filtrar, transformar, presentar) es la base de cualquier pantalla de listado (LazyColumn).

17. Buenas prácticas de estilo

Aspecto Convención Ejemplo
Nombre de variables sustantivo, minúsculas, camelCase velocidad, numeroCuentas
Nombres booleanos adjetivo, o sufijos is/has/can isReady, hasPermisos
Funciones verbo en infinitivo calcularMedia(), validarDatos()
Números mágicos en constante nombrada private val IVA = 1.21
Constantes reales const val en mayúsculas const val MAX_INTENTOS = 3

18. Errores frecuentes

Error Síntoma Arreglo
Confundir ? con !! NPE pese al ? el ? protege; el !! apuesta
filter esperando mutación "no me ha quitado nada" filter devuelve otra lista
Usar values() en enums nuevos deprecado entries
Olvidar open "la clase es final" open en base, override en derivada
== pensando en referencias compara contenidos === para identidad
sortedBy vs sortBy sortBy no existe en inmutables sortedBy devuelve copia

19. Test de autoevaluación

  1. ¿Qué imprime val x: Int? = null; println(x?.toString() ?: "nada")?
  2. Diferencia entre sortedBy y sortBy: ¿cuál existe en una List inmutable?
  3. ¿Por qué mapOf("a" to 1)["z"] no lanza excepción pero listOf(1)[9] sí?
  4. ¿Qué te da data class que una clase normal no tiene?
  5. ¿Cuándo un when no necesita else?
  6. ::esPar dentro de filter — ¿qué es y qué alternativa equivalente hay?
  7. ¿Qué hace require(condición) { msg } y qué lanza?
  8. ¿Por qué la regla de oro es val por defecto?

Respuestas

  1. nada (safe call → null; Elvis activa el rescate). 2. sortedBy devuelve una copia ordenada —existe en inmutables—; sortBy ordena en sitio y solo existe en MutableList. 3. Los mapas devuelven null ante clave inexistente; las listas lanzan IndexOutOfBounds. 4. equals/hashCode/toString/copy/componentN generados. 5. Cuando el compilador puede probar que cubres todos los casos (enums con todas sus constantes, o sellados). 6. Una referencia a función; la alternativa es filter { esPar(it) }. 7. Comprueba la precondición y lanza IllegalArgumentException con el mensaje si falla. 8. Porque lo inmutable es más seguro, legible y trivialmente concurrente.

20. Para terminar

Este tema es la base de todo lo que viene: actividades, Compose, Room… usan estos mismos fundamentos.

Recursos: Sintaxis · Null-safety · Colecciones