Diferencias

Muestra las diferencias entre dos versiones de la página.

--- bloque2:juegos [2026/09/08 22:41] – [39. Lo que debes dominar antes de continuar] fernando
+++ bloque2:juegos [2026/09/11 12:30] (actual) – borrado fernando
@@ Línea 1: / Línea 1: @@
-====== Fundamentos del lenguaje Kotlin ======
-===== 1. Introducción a Kotlin =====
-Kotlin es un lenguaje de programación moderno desarrollado por **JetBrains**.
-Aunque puede utilizarse para diferentes tipos de aplicaciones, tiene especial importancia en el desarrollo de aplicaciones para **Android**.
-Kotlin es compatible con Java y puede utilizar bibliotecas desarrolladas para Java.
-En este tema aprenderemos los fundamentos necesarios para comenzar a programar en Kotlin y utilizarlos posteriormente en el desarrollo de aplicaciones Android.
-===== 2. Objetivos del tema =====
-Al finalizar este tema deberás ser capaz de:
-  * Crear y ejecutar un programa básico en Kotlin.
-  * Comprender la estructura de un programa Kotlin.
-  * Declarar variables y constantes.
-  * Diferenciar entre ''val'' y ''var''.
-  * Utilizar los principales tipos de datos.
-  * Realizar conversiones entre tipos.
-  * Utilizar operadores.
-  * Trabajar con cadenas de texto.
-  * Tomar decisiones mediante ''if'' y ''when''.
-  * Repetir instrucciones mediante ''while'', ''do...while'' y ''for''.
-  * Utilizar ''break'' y ''continue''.
-  * Crear y utilizar arrays.
-  * Trabajar con rangos.
-  * Crear funciones con y sin parámetros.
-  * Devolver valores desde una función.
-  * Utilizar parámetros con valores por defecto.
-  * Comprender la sintaxis abreviada de las funciones.
-===== 3. Primer programa =====
-El programa más sencillo que podemos escribir en Kotlin es:
-<code kotlin>
-fun main() {
-    println("Hola mundo")
-}
-</code>
-Al ejecutarlo obtenemos:
-<code>
-Hola mundo
-</code>
-==== 3.1. La función main ====
-La función `main()` es el punto de entrada de nuestro programa.
-<code kotlin>
-fun main() {
-} </code>
-Todo lo que queramos ejecutar al comenzar el programa puede colocarse dentro de ella.
-Por ejemplo:
-<code kotlin>
-fun main() {
-    println("Inicio del programa")
-```
-println("Fin del programa")
-```
-} </code>
-==== 3.2. Las llaves ====
-Las llaves `{}` delimitan un bloque de código.
-<code kotlin>
-fun main() {
-    println("Primera instrucción")
-    println("Segunda instrucción")
-}
-</code>
-==== 3.3. Punto y coma ====
-En Kotlin no es necesario utilizar `;` al final de las instrucciones.
-Correcto:
-<code kotlin>
-println("Hola")
-println("Adiós")
-</code>
-Aunque el lenguaje permite utilizar punto y coma, no es habitual hacerlo.
-==== Ejercicio 1 ====
-Crea un programa que muestre por pantalla:
-<code>
-Bienvenido a Kotlin
-Estoy aprendiendo programación
-Este es mi primer programa
-</code>
-===== 4. Sintaxis básica =====
-Kotlin utiliza una sintaxis relativamente sencilla y concisa.
-Por ejemplo:
-<code kotlin>
-val nombre = "Ana"
-val edad = 20
-println("Nombre: $nombre")
-println("Edad: $edad") </code>
-No es necesario indicar siempre explícitamente el tipo de una variable.
-Kotlin puede deducirlo automáticamente.
-==== 4.1. Mayúsculas y minúsculas ====
-Kotlin distingue entre mayúsculas y minúsculas.
-Por ejemplo:
-<code kotlin>
-val nombre = "Ana"
-val Nombre = "Luis"
-</code>
-`nombre` y `Nombre` son identificadores diferentes.
-Por convenio, debemos utilizar nombres descriptivos y seguir la nomenclatura habitual:
-<code kotlin>
-val nombreAlumno = "Ana"
-val numeroDeAlumnos = 25
-</code>
-Se recomienda utilizar **camelCase** para variables y funciones.
-===== 5. Comentarios =====
-Los comentarios permiten añadir explicaciones al código que no serán ejecutadas.
-==== 5.1. Comentarios de una línea ====
-<code kotlin>
-// Este es un comentario
-val edad = 20 </code>
-También pueden colocarse al final de una instrucción:
-<code kotlin>
-val edad = 20 // Edad del alumno
-</code>
-==== 5.2. Comentarios de varias líneas ====
-<code kotlin>
-/*
-    Este comentario ocupa
-    varias líneas.
-*/
-</code>
-Los comentarios son útiles para documentar el código, pero debemos evitar comentarios innecesarios.
-El código debería ser suficientemente claro por sí mismo.
-===== 6. Mostrar información por pantalla =====
-Kotlin proporciona principalmente dos funciones para mostrar información:
-* `print()`
-* `println()`
-==== 6.1. println ====
-`println()` muestra información y después realiza un salto de línea.
-<code kotlin>
-println("Hola")
-println("Mundo")
-</code>
-Resultado:
-<code>
-Hola
-Mundo
-</code>
-==== 6.2. print ====
-`print()` muestra información pero no realiza un salto de línea.
-<code kotlin>
-print("Hola ")
-print("Mundo")
-</code>
-Resultado:
-<code>
-Hola Mundo
-</code>
-==== 6.3. Mostrar variables ====
-<code kotlin>
-val nombre = "Ana"
-println(nombre) </code>
-También podemos combinar texto y variables.
-<code kotlin>
-val nombre = "Ana"
-val edad = 20
-println("Nombre: $nombre")
-println("Edad: $edad") </code>
-Esto se denomina **interpolación de cadenas**.
-===== 7. Variables =====
-Una variable permite almacenar un valor en memoria.
-En Kotlin utilizamos principalmente dos palabras clave:
-<code>
-val
-var
-</code>
-==== 7.1. val ====
-Una variable declarada mediante `val` no puede ser reasignada después de su inicialización.
-<code kotlin>
-val nombre = "Ana"
-</code>
-Esto produciría un error:
-<code kotlin>
-val nombre = "Ana"
-nombre = "Luis" </code>
-Una vez asignado `"Ana"`, no podemos asignar otro valor a `nombre`.
-==== 7.2. var ====
-Una variable declarada mediante `var` sí puede cambiar de valor.
-<code kotlin>
-var edad = 20
-edad = 21
-edad = 22 </code>
-==== 7.3. ¿Cuándo utilizamos val y cuándo var? ====
-Como regla general:
-> **Utiliza `val` por defecto y utiliza `var` solamente cuando necesites cambiar el valor.**
-Ejemplo:
-<code kotlin>
-val nombre = "Ana"
-val fechaNacimiento = 2005
-var edad = 20
-edad = 21 </code>
-`nombre` y `fechaNacimiento` no necesitan ser reasignadas.
-`edad`, en cambio, sí cambia.
-==== 7.4. Inferencia de tipos ====
-Kotlin puede deducir el tipo de una variable a partir del valor que almacenamos.
-<code kotlin>
-val edad = 20
-val nombre = "Ana"
-val altura = 1.75
-val activo = true
-</code>
-Kotlin deduce:
-<code>
-edad    → Int
-nombre  → String
-altura  → Double
-activo  → Boolean
-</code>
-Esto se denomina **inferencia de tipos**.
-==== 7.5. Declarar el tipo explícitamente ====
-También podemos indicar el tipo:
-<code kotlin>
-val edad: Int = 20
-val nombre: String = "Ana"
-val altura: Double = 1.75
-val activo: Boolean = true
-</code>
-La sintaxis es:
-<code>
-val nombreVariable: Tipo = valor
-</code>
-o:
-<code>
-var nombreVariable: Tipo = valor
-</code>
-==== 7.6. ¿Qué estilo debemos utilizar? ====
-Normalmente:
-<code kotlin>
-val edad = 20
-</code>
-es preferible a:
-<code kotlin>
-val edad: Int = 20
-</code>
-cuando el tipo resulta evidente.
-Sin embargo, indicar explícitamente el tipo puede mejorar la claridad en determinadas situaciones.
-==== Error frecuente ====
-Confundir `val` con una constante absoluta.
-<code kotlin>
-val numeros = arrayOf(1, 2, 3)
-numeros[0] = 10 </code>
-La referencia `numeros` no puede apuntar a otro array, pero los elementos del array pueden modificarse.
-La diferencia entre `val` y `var` se refiere a la **reasignación de la variable**.
-==== Ejercicios ====
-=== Ejercicio 2 ===
-Declara las siguientes variables utilizando inferencia de tipos:
-* Nombre: `"Carlos"`
-* Edad: `21`
-* Altura: `1.82`
-* Es estudiante: `true`
-=== Ejercicio 3 ===
-Indica cuáles de estas variables deberían declararse como `val` y cuáles como `var`:
-* Nombre de una persona.
-* Edad de una persona que va aumentando.
-* Número de teléfono.
-* Contador de un bucle.
-* Precio de un producto.
-===== 8. Tipos de datos =====
-Kotlin dispone de diferentes tipos de datos.
-Los más importantes en esta primera etapa son:
-^ Tipo ^ Uso ^
-| `Int` | Números enteros |
-| `Long` | Números enteros grandes |
-| `Double` | Números decimales |
-| `Float` | Números decimales |
-| `Boolean` | Verdadero / falso |
-| `Char` | Un carácter |
-| `String` | Texto |
-===== 9. Números enteros =====
-==== 9.1. Int ====
-`Int` es el tipo que utilizaremos normalmente para números enteros.
-<code kotlin>
-val edad = 20
-val numeroAlumnos = 25
-val temperatura = -5
-</code>
-También podemos indicarlo explícitamente:
-<code kotlin>
-val edad: Int = 20
-</code>
-==== 9.2. Long ====
-`Long` permite trabajar con números enteros de mayor tamaño.
-<code kotlin>
-val poblacion: Long = 48000000
-</code>
-Podemos utilizar `L` para indicar explícitamente un literal `Long`:
-<code kotlin>
-val numero = 48000000L
-</code>
-===== 10. Números decimales =====
-==== 10.1. Double ====
-`Double` es el tipo decimal que utilizaremos habitualmente.
-<code kotlin>
-val altura = 1.82
-val precio = 19.95
-</code>
-También podemos indicar el tipo:
-<code kotlin>
-val altura: Double = 1.82
-</code>
-==== 10.2. Float ====
-Para utilizar `Float` debemos añadir normalmente `f` al número:
-<code kotlin>
-val temperatura: Float = 23.5f
-</code>
-En la mayoría de los programas utilizaremos `Double` salvo que necesitemos específicamente `Float`.
-===== 11. Boolean =====
-Un `Boolean` solamente puede tener dos valores:
-<code>
-true
-false
-</code>
-Ejemplo:
-<code kotlin>
-val mayorDeEdad = true
-val tieneCarnet = false
-</code>
-Los booleanos son especialmente importantes para las estructuras condicionales.
-<code kotlin>
-val edad = 20
-if (edad >= 18) {
-println("Es mayor de edad")
-} </code>
-===== 12. Char =====
-`Char` representa un único carácter.
-<code kotlin>
-val letra: Char = 'A'
-</code>
-Los caracteres se escriben entre comillas simples.
-<code kotlin>
-'A'
-'7'
-'?'
-</code>
-No debemos confundir:
-<code kotlin>
-val letra = 'A'
-val texto = "A"
-</code>
-`letra` es `Char`, mientras que `texto` es `String`.
-===== 13. String =====
-`String` representa una cadena de caracteres.
-<code kotlin>
-val nombre = "Ana"
-val ciudad = "León"
-</code>
-Los textos se escriben entre comillas dobles.
-==== 13.1. Interpolación ====
-Kotlin permite introducir variables directamente dentro de un `String`.
-<code kotlin>
-val nombre = "Ana"
-val edad = 20
-println("Me llamo $nombre y tengo $edad años") </code>
-También podemos utilizar expresiones:
-<code kotlin>
-println("El año que viene tendré ${edad + 1} años")
-</code>
-==== 13.2. Cadenas multilínea ====
-Podemos utilizar tres comillas dobles:
-<code kotlin>
-val texto = """
-    Primera línea
-    Segunda línea
-    Tercera línea
-""".trimIndent()
-</code>
-===== 14. Conversión de tipos =====
-Kotlin no realiza automáticamente todas las conversiones numéricas.
-Por ejemplo:
-<code kotlin>
-val numero: Int = 10
-val decimal: Double = numero
-</code>
-No debemos asumir que esta conversión se realizará automáticamente.
-Utilizaremos funciones como:
-<code>
-toByte()
-toShort()
-toInt()
-toLong()
-toFloat()
-toDouble()
-</code>
-Ejemplo:
-<code kotlin>
-val numero = 10
-val decimal = numero.toDouble() </code>
-Otro ejemplo:
-<code kotlin>
-val numero = 10.8
-val entero = numero.toInt()
-println(entero) </code>
-Resultado:
-<code>
-</code>
-==== Ejercicio 4 ====
-Crea un programa que:
-* Declare un número entero.
-* Lo convierta a `Double`.
-* Muestre ambos valores.
-===== 15. Operadores =====
-Los operadores permiten realizar operaciones con datos.
-===== 15.1. Operadores aritméticos =====
-^ Operador ^ Significado ^
-| `+` | Suma |
-| `-` | Resta |
-| `*` | Multiplicación |
-| `/` | División |
-| `%` | Resto |
-Ejemplo:
-<code kotlin>
-val a = 10
-val b = 3
-println(a + b)
-println(a - b)
-println(a * b)
-println(a / b)
-println(a % b) </code>
-==== 15.2. División entera ====
-Si dividimos dos `Int`, obtenemos un `Int`.
-<code kotlin>
-val resultado = 10 / 3
-println(resultado) </code>
-Resultado:
-<code>
-</code>
-Si queremos obtener un resultado decimal:
-<code kotlin>
-val resultado = 10.0 / 3.0
-println(resultado) </code>
-==== 15.3. Módulo ====
-El operador `%` devuelve el resto de una división.
-<code kotlin>
-println(10 % 3)
-</code>
-Resultado:
-<code>
-</code>
-Es muy útil para determinar si un número es par:
-<code kotlin>
-val numero = 8
-if (numero % 2 == 0) {
-println("Es par")
-} </code>
-===== 16. Operadores de asignación =====
-Asignación:
-<code kotlin>
-var puntos = 10
-puntos = 20 </code>
-También podemos utilizar operadores abreviados:
-<code kotlin>
-puntos += 5
-puntos -= 5
-puntos *= 2
-puntos /= 2
-puntos %= 2
-</code>
-Por ejemplo:
-<code kotlin>
-var puntos = 10
-puntos += 5 </code>
-equivale a:
-<code kotlin>
-puntos = puntos + 5
-</code>
-===== 17. Incremento y decremento =====
-Podemos incrementar una variable:
-<code kotlin>
-var contador = 0
-contador++ </code>
-También podemos utilizar:
-<code kotlin>
-contador--
-</code>
-Son especialmente habituales en bucles.
-===== 18. Operadores de comparación =====
-Los principales operadores son:
-^ Operador ^ Significado ^
-| `==` | Igual |
-| `!=` | Distinto |
-| `>` | Mayor |
-| `<` | Menor |
-| `>=` | Mayor o igual |
-| `<=` | Menor o igual |
-Ejemplo:
-<code kotlin>
-val edad = 20
-println(edad >= 18) </code>
-Resultado:
-<code>
-true
-</code>
-==== Importante: `=` no es `==` ====
-`=` se utiliza para asignar:
-<code kotlin>
-var edad = 20
-edad = 21
-</code>
-`==` se utiliza para comparar:
-<code kotlin>
-if (edad == 21) {
-    println("Tiene 21 años")
-}
-</code>
-===== 19. Operadores lógicos =====
-^ Operador ^ Significado ^
-| `&&` | AND |
-| `||` | OR |
-| `!` | NOT |
-==== 19.1. AND ====
-`&&` devuelve `true` cuando ambas condiciones son verdaderas.
-<code kotlin>
-val edad = 20
-val tieneCarnet = true
-if (edad >= 18 && tieneCarnet) {
-println("Puede conducir")
-} </code>
-==== 19.2. OR ====
-`||` devuelve `true` cuando al menos una condición es verdadera.
-<code kotlin>
-val esSabado = true
-val esDomingo = false
-if (esSabado || esDomingo) {
-println("Es fin de semana")
-} </code>
-==== 19.3. NOT ====
-`!` invierte el valor lógico.
-<code kotlin>
-val activo = true
-println(!activo) </code>
-Resultado:
-<code>
-false
-</code>
-===== 20. Strings =====
-Las cadenas de texto son uno de los tipos que más utilizaremos en una aplicación.
-==== 20.1. Concatenación ====
-Podemos utilizar `+`:
-<code kotlin>
-val nombre = "Ana"
-val apellido = "García"
-val nombreCompleto = nombre + " " + apellido </code>
-Sin embargo, normalmente resulta más cómodo utilizar interpolación:
-<code kotlin>
-val nombreCompleto = "$nombre $apellido"
-</code>
-==== 20.2. Longitud de una cadena ====
-Podemos obtener la longitud utilizando `length`:
-<code kotlin>
-val nombre = "Kotlin"
-println(nombre.length) </code>
-Resultado:
-<code>
-</code>
-==== 20.3. Acceder a caracteres ====
-Podemos acceder a un carácter mediante su posición:
-<code kotlin>
-val nombre = "Kotlin"
-println(nombre[0])
-println(nombre[1]) </code>
-Resultado:
-<code>
-K
-o
-</code>
-Como ocurre con los arrays, los índices comienzan en `0`.
-==== Ejercicio 5 ====
-Crea un programa que:
-* Guarde tu nombre en una variable.
-* Muestre el nombre.
-* Muestre cuántos caracteres tiene.
-* Muestre su primer carácter.
-===== 21. Estructuras condicionales =====
-Las estructuras condicionales permiten ejecutar diferentes instrucciones dependiendo de una condición.
-===== 21.1. if =====
-Sintaxis:
-<code kotlin>
-if (condicion) {
-    // instrucciones
-}
-</code>
-Ejemplo:
-<code kotlin>
-val edad = 20
-if (edad >= 18) {
-println("Mayor de edad")
-} </code>
-===== 21.2. if...else =====
-<code kotlin>
-val edad = 16
-if (edad >= 18) {
-println("Mayor de edad")
-} else {
-println("Menor de edad")
-} </code>
-===== 21.3. if...else if...else =====
-Podemos comprobar varias condiciones:
-<code kotlin>
-val nota = 7
-if (nota >= 9) {
-println("Sobresaliente")
-} else if (nota >= 7) {
-println("Notable")
-} else if (nota >= 5) {
-println("Aprobado")
-} else {
-println("Suspenso")
-} </code>
-===== 21.4. if como expresión =====
-Una característica importante de Kotlin es que `if` puede devolver un valor.
-<code kotlin>
-val edad = 20
-val mensaje = if (edad >= 18) {
-"Mayor de edad"
-} else {
-"Menor de edad"
-}
-println(mensaje) </code>
-También podemos escribirlo de forma más compacta:
-<code kotlin>
-val mensaje = if (edad >= 18) "Mayor de edad" else "Menor de edad"
-</code>
-En Kotlin no necesitamos utilizar el operador ternario que existe en otros lenguajes.
-===== Ejercicios de if =====
-=== Ejercicio 6 ===
-Crea un programa que indique si un número es positivo, negativo o cero.
-=== Ejercicio 7 ===
-Crea un programa que reciba una edad y muestre:
-* Menor de edad.
-* Adulto.
-* Mayor de 65 años.
-=== Ejercicio 8 ===
-Crea un programa que reciba una nota de 0 a 10 y muestre:
-* Suspenso: < 5
-* Aprobado: 5–6
-* Notable: 7–8
-* Sobresaliente: 9–10
-===== 22. when =====
-`when` permite seleccionar una opción entre diferentes posibilidades.
-Es conceptualmente parecido a `switch` en otros lenguajes.
-Sintaxis:
-<code kotlin>
-when (valor) {
-    valor1 -> instrucciones
-    valor2 -> instrucciones
-    else -> instrucciones
-}
-</code>
-Ejemplo:
-<code kotlin>
-val dia = 3
-when (dia) {
--> println("Lunes")
--> println("Martes")
--> println("Miércoles")
--> println("Jueves")
--> println("Viernes")
--> println("Sábado")
--> println("Domingo")
-else -> println("Día incorrecto")
-} </code>
-==== 22.1. Varias posibilidades ====
-Podemos agrupar varios valores:
-<code kotlin>
-val dia = 6
-when (dia) {
-, 2, 3, 4, 5 -> println("Día laborable")
-, 7 -> println("Fin de semana")
-else -> println("Día incorrecto")
-} </code>
-==== 22.2. when como expresión ====
-`when` también puede devolver un valor.
-<code kotlin>
-val nota = 8
-val resultado = when (nota) {
--> "Matrícula"
--> "Sobresaliente"
-, 8 -> "Notable"
-, 6 -> "Aprobado"
-else -> "Suspenso"
-}
-println(resultado) </code>
-==== 22.3. when sin argumento ====
-También podemos utilizar `when` para evaluar condiciones:
-<code kotlin>
-val edad = 25
-when {
-edad < 18 -> println("Menor de edad")
-edad < 65 -> println("Adulto")
-else -> println("Mayor de 65")
-} </code>
-==== ¿Cuándo utilizar if y cuándo when? ====
-Como regla práctica:
-* Utiliza `if` cuando tengas que comprobar una condición o pocas condiciones.
-* Utiliza `when` cuando tengas diferentes posibilidades claramente diferenciadas.
-===== Ejercicios de when =====
-=== Ejercicio 9 ===
-Crea un programa que reciba un número del 1 al 12 y muestre el mes correspondiente.
-=== Ejercicio 10 ===
-Crea un programa que reciba una opción de menú:
-<code>
-→ Alta
-→ Baja
-→ Modificar
-→ Consultar
-</code>
-Utiliza `when`.
-===== 23. Bucle while =====
-Los bucles permiten repetir instrucciones.
-`while` repite un bloque mientras una condición sea verdadera.
-Sintaxis:
-<code kotlin>
-while (condicion) {
-    // instrucciones
-}
-</code>
-Ejemplo:
-<code kotlin>
-var contador = 1
-while (contador <= 5) {
-println(contador)
-contador++
-} </code>
-Resultado:
-<code>
-</code>
-===== 23.1. Cuidado con los bucles infinitos =====
-Debemos asegurarnos de que la condición pueda llegar a ser falsa.
-Incorrecto:
-<code kotlin>
-var contador = 1
-while (contador <= 5) {
-println(contador)
-} </code>
-`contador` nunca cambia, por lo que la condición siempre será verdadera.
-Correcto:
-<code kotlin>
-var contador = 1
-while (contador <= 5) {
-println(contador)
-contador++
-} </code>
-===== 24. do...while =====
-La estructura `do...while` ejecuta el bloque antes de comprobar la condición.
-<code kotlin>
-var contador = 1
-do {
-println(contador)
-contador++
-} while (contador <= 5) </code>
-La principal diferencia es:
-<code>
-while
-    → comprueba primero
-do...while
-→ ejecuta primero y comprueba después </code>
-Por tanto, un `do...while` ejecuta su cuerpo al menos una vez.
-===== Ejercicio 11 =====
-Crea un programa que muestre los números del 10 al 1 utilizando `while`.
-===== 25. break =====
-`break` termina inmediatamente el bucle.
-<code kotlin>
-var contador = 1
-while (contador <= 10) {
-```
-if (contador == 5) {
-    break
-}
-println(contador)
-contador++
-```
-} </code>
-Resultado:
-<code>
-</code>
-===== 26. continue =====
-`continue` termina la iteración actual y pasa a la siguiente.
-<code kotlin>
-var contador = 0
-while (contador < 5) {
-```
-contador++
-if (contador == 3) {
-    continue
-}
-println(contador)
-```
-} </code>
-Resultado:
-<code>
-</code>
-===== Ejercicio 12 =====
-Crea un programa que recorra los números del 1 al 20 y muestre solamente los números pares.
-Hazlo utilizando `continue`.
-===== 27. Arrays =====
-Un array permite almacenar varios elementos.
-Se puede crear mediante `arrayOf()`:
-<code kotlin>
-val numeros = arrayOf(10, 20, 30, 40, 50)
-</code>
-Los elementos están indexados comenzando por `0`.
-<code>
-Índice:    0    1    2    3    4
-Valor:    10   20   30   40   50
-</code>
-===== 27.1. Acceder a elementos =====
-<code kotlin>
-val numeros = arrayOf(10, 20, 30)
-println(numeros[0])
-println(numeros[1])
-println(numeros[2]) </code>
-===== 27.2. Modificar elementos =====
-Podemos modificar un elemento:
-<code kotlin>
-val numeros = arrayOf(10, 20, 30)
-numeros[0] = 100 </code>
-Ahora el array contiene:
-<code>
-, 20, 30
-</code>
-===== 27.3. Tamaño de un array =====
-Utilizamos `size`:
-<code kotlin>
-val numeros = arrayOf(10, 20, 30, 40)
-println(numeros.size) </code>
-Resultado:
-<code>
-</code>
-===== 27.4. Arrays de Strings =====
-<code kotlin>
-val nombres = arrayOf("Ana", "Luis", "Marta")
-</code>
-Podemos acceder a sus elementos:
-<code kotlin>
-println(nombres[0])
-</code>
-===== 27.5. Comprobar si existe un elemento =====
-Podemos utilizar `in`:
-<code kotlin>
-val nombres = arrayOf("Ana", "Luis", "Marta")
-if ("Luis" in nombres) {
-println("Luis está en el array")
-} </code>
-===== 27.6. Error de índice =====
-No podemos acceder a una posición que no existe.
-<code kotlin>
-val numeros = arrayOf(10, 20, 30)
-println(numeros[3]) </code>
-El último índice válido es `2`.
-Los índices van de:
-<code>
-hasta size - 1
-</code>
-===== Ejercicio 13 =====
-Crea un array con cinco nombres.
-Muestra:
-* El primer nombre.
-* El último nombre.
-* El número de elementos.
-===== 28. Bucle for =====
-`for` permite recorrer elementos de una colección o un rango.
-Ejemplo:
-<code kotlin>
-val nombres = arrayOf("Ana", "Luis", "Marta")
-for (nombre in nombres) {
-println(nombre)
-} </code>
-Resultado:
-<code>
-Ana
-Luis
-Marta
-</code>
-===== 28.1. Recorrer números =====
-<code kotlin>
-for (numero in 1..5) {
-    println(numero)
-}
-</code>
-===== 28.2. Recorrer un String =====
-Los caracteres de una cadena también pueden recorrerse:
-<code kotlin>
-val nombre = "Kotlin"
-for (letra in nombre) {
-println(letra)
-} </code>
-===== 28.3. Índices de un array =====
-Podemos utilizar `indices`:
-<code kotlin>
-val nombres = arrayOf("Ana", "Luis", "Marta")
-for (i in nombres.indices) {
-println(nombres[i])
-} </code>
-También podemos obtener índice y valor mediante `withIndex()`:
-<code kotlin>
-for ((indice, nombre) in nombres.withIndex()) {
-    println("$indice: $nombre")
-}
-</code>
-===== Ejercicio 14 =====
-Crea un array de cinco números y utiliza un `for` para calcular la suma de todos ellos.
-===== 29. Rangos =====
-Kotlin dispone de una sintaxis específica para crear rangos.
-===== 29.1. Rango ascendente =====
-<code kotlin>
-..5
-</code>
-Representa:
-<code>
-, 2, 3, 4, 5
-</code>
-Ejemplo:
-<code kotlin>
-for (i in 1..5) {
-    println(i)
-}
-</code>
-===== 29.2. Rango descendente =====
-Utilizamos `downTo`:
-<code kotlin>
-for (i in 5 downTo 1) {
-    println(i)
-}
-</code>
-Resultado:
-<code>
-</code>
-===== 29.3. Saltos mediante step =====
-<code kotlin>
-for (i in 0..10 step 2) {
-    println(i)
-}
-</code>
-Resultado:
-<code>
-</code>
-===== 29.4. Rango sin incluir el límite superior =====
-Podemos utilizar `..<`:
-<code kotlin>
-for (i in 1..<5) {
-    println(i)
-}
-</code>
-Resultado:
-<code>
-</code>
-Esto resulta especialmente útil para trabajar con índices.
-===== Ejercicio 15 =====
-Realiza los siguientes recorridos:
-* Números del 1 al 10.
-* Números del 10 al 1.
-* Números pares del 0 al 20.
-* Números impares del 1 al 19.
-===== 30. Funciones =====
-Una función es un bloque de código que realiza una tarea concreta.
-Las funciones se declaran mediante la palabra clave `fun`.
-===== 30.1. Crear una función =====
-<code kotlin>
-fun saludar() {
-    println("Hola")
-}
-</code>
-Para ejecutar la función:
-<code kotlin>
-saludar()
-</code>
-Programa completo:
-<code kotlin>
-fun saludar() {
-    println("Hola")
-}
-fun main() {
-saludar()
-} </code>
-===== 30.2. ¿Por qué utilizar funciones? =====
-Las funciones permiten:
-* Dividir un programa grande en partes pequeñas.
-* Evitar repetir código.
-* Mejorar la legibilidad.
-* Facilitar el mantenimiento.
-* Reutilizar código.
-* Separar responsabilidades.
-Por ejemplo, en lugar de:
-<code kotlin>
-println("Bienvenido")
-println("Bienvenido")
-println("Bienvenido")
-</code>
-podemos crear:
-<code kotlin>
-fun mostrarBienvenida() {
-    println("Bienvenido")
-}
-fun main() {
-mostrarBienvenida()
-mostrarBienvenida()
-mostrarBienvenida()
-} </code>
-===== 30.3. Parámetros =====
-Una función puede recibir información mediante parámetros.
-<code kotlin>
-fun saludar(nombre: String) {
-    println("Hola $nombre")
-}
-</code>
-Podemos llamarla:
-<code kotlin>
-saludar("Ana")
-saludar("Luis")
-</code>
-Resultado:
-<code>
-Hola Ana
-Hola Luis
-</code>
-===== 30.4. Varios parámetros =====
-<code kotlin>
-fun presentar(nombre: String, edad: Int) {
-    println("$nombre tiene $edad años")
-}
-</code>
-Llamada:
-<code kotlin>
-presentar("Ana", 20)
-</code>
-Cada parámetro tiene:
-<code>
-nombre: Tipo
-</code>
-Por ejemplo:
-<code kotlin>
-nombre: String
-edad: Int
-altura: Double
-</code>
-===== 30.5. Valor de retorno =====
-Una función puede devolver un valor.
-<code kotlin>
-fun sumar(a: Int, b: Int): Int {
-    return a + b
-}
-</code>
-La parte:
-<code>
-: Int
-</code>
-indica que la función devuelve un `Int`.
-Podemos guardar el resultado:
-<code kotlin>
-val resultado = sumar(10, 20)
-println(resultado) </code>
-Resultado:
-<code>
-</code>
-===== 30.6. return =====
-La palabra `return` indica qué valor devuelve la función.
-<code kotlin>
-fun multiplicar(a: Int, b: Int): Int {
-    return a * b
-}
-</code>
-===== 30.7. Funciones sin retorno útil =====
-Una función que no devuelve un valor útil puede escribirse:
-<code kotlin>
-fun mostrarMensaje() {
-    println("Hola")
-}
-</code>
-Internamente su retorno es `Unit`, pero normalmente no necesitamos escribirlo.
-También podríamos escribir:
-<code kotlin>
-fun mostrarMensaje(): Unit {
-    println("Hola")
-}
-</code>
-pero la primera forma es la habitual.
-===== 30.8. Funciones de una sola expresión =====
-Cuando una función solamente tiene una expresión podemos utilizar una sintaxis abreviada.
-En lugar de:
-<code kotlin>
-fun sumar(a: Int, b: Int): Int {
-    return a + b
-}
-</code>
-podemos escribir:
-<code kotlin>
-fun sumar(a: Int, b: Int): Int = a + b
-</code>
-Incluso podemos dejar que Kotlin deduzca el tipo de retorno:
-<code kotlin>
-fun sumar(a: Int, b: Int) = a + b
-</code>
-Otro ejemplo:
-<code kotlin>
-fun cuadrado(numero: Int) = numero * numero
-</code>
-Esta sintaxis es habitual en Kotlin.
-===== 30.9. Parámetros con valores por defecto =====
-Podemos proporcionar un valor por defecto a un parámetro.
-<code kotlin>
-fun saludar(nombre: String = "usuario") {
-    println("Hola $nombre")
-}
-</code>
-Ahora podemos hacer:
-<code kotlin>
-saludar()
-</code>
-Resultado:
-<code>
-Hola usuario
-</code>
-También podemos proporcionar nuestro propio valor:
-<code kotlin>
-saludar("Ana")
-</code>
-Resultado:
-<code>
-Hola Ana
-</code>
-===== 30.10. Argumentos con nombre =====
-Podemos indicar explícitamente qué parámetro estamos proporcionando:
-<code kotlin>
-fun presentar(nombre: String, edad: Int) {
-    println("$nombre tiene $edad años")
-}
-presentar(nombre = "Ana", edad = 20) </code>
-También podemos cambiar el orden:
-<code kotlin>
-presentar(edad = 20, nombre = "Ana")
-</code>
-Esto puede hacer que las llamadas a funciones sean más fáciles de leer.
-===== Ejercicios de funciones =====
-=== Ejercicio 16 ===
-Crea una función:
-<code>
-saludar()
-</code>
-que muestre un saludo.
-=== Ejercicio 17 ===
-Crea una función:
-<code>
-saludar(nombre)
-</code>
-que reciba un nombre y muestre:
-<code>
-Hola, nombre
-</code>
-=== Ejercicio 18 ===
-Crea una función `sumar()` que reciba dos números enteros y devuelva su suma.
-=== Ejercicio 19 ===
-Crea las siguientes funciones:
-<code>
-restar()
-multiplicar()
-dividir()
-</code>
-Cada función debe recibir dos números y devolver el resultado correspondiente.
-=== Ejercicio 20 ===
-Crea una función que reciba una edad y devuelva `true` si la persona es mayor de edad y `false` en caso contrario.
-===== 31. Buenas prácticas =====
-Desde el principio debemos acostumbrarnos a escribir código claro.
-==== 31.1. Utilizar nombres descriptivos ====
-Evitar:
-<code kotlin>
-val x = 20
-val y = "Ana"
-</code>
-Preferir:
-<code kotlin>
-val edad = 20
-val nombre = "Ana"
-</code>
-==== 31.2. Utilizar val cuando sea posible ====
-Preferir:
-<code kotlin>
-val nombre = "Ana"
-</code>
-frente a:
-<code kotlin>
-var nombre = "Ana"
-</code>
-si no necesitamos modificar la variable.
-==== 31.3. Funciones pequeñas ====
-Una función debería realizar una tarea concreta.
-Evitar funciones enormes que hagan muchas cosas diferentes.
-Por ejemplo:
-<code kotlin>
-fun calcularMedia(...)
-</code>
-debería encargarse de calcular una media.
-Otra función:
-<code kotlin>
-fun mostrarResultado(...)
-</code>
-puede encargarse de mostrar el resultado.
-==== 31.4. Evitar repetir código ====
-Si escribimos varias veces el mismo código, probablemente podamos convertirlo en una función.
-===== 32. Ejemplo integrador 1 =====
-El siguiente programa combina variables, tipos, operadores y condicionales.
-<code kotlin>
-fun main() {
-```
-val nombre = "Ana"
-val nota1 = 7.0
-val nota2 = 8.0
-val nota3 = 6.0
-val media = (nota1 + nota2 + nota3) / 3
-println("Alumno: $nombre")
-println("Media: $media")
-if (media >= 5) {
-    println("Resultado: Aprobado")
-} else {
-    println("Resultado: Suspenso")
-}
-```
-} </code>
-===== 33. Ejemplo integrador 2 — Funciones =====
-Podemos mejorar el programa anterior separando responsabilidades.
-<code kotlin>
-fun calcularMedia(nota1: Double, nota2: Double, nota3: Double): Double {
-    return (nota1 + nota2 + nota3) / 3
-}
-fun obtenerResultado(media: Double): String {
-```
-return if (media >= 5) {
-    "Aprobado"
-} else {
-    "Suspenso"
-}
-```
-}
-fun main() {
-```
-val nombre = "Ana"
-val media = calcularMedia(
-.0,
-.0,
-.0
-)
-val resultado = obtenerResultado(media)
-println("Alumno: $nombre")
-println("Media: $media")
-println("Resultado: $resultado")
-```
-} </code>
-Aquí estamos utilizando:
-* Variables.
-* `val`.
-* `Double`.
-* Operadores aritméticos.
-* `if`.
-* `String`.
-* Interpolación.
-* Funciones.
-* Parámetros.
-* Valores de retorno.
-* `return`.
-===== 34. Ejemplo integrador 3 — Arrays y bucles =====
-<code kotlin>
-fun calcularMedia(notas: Array<Int>): Double {
-```
-var suma = 0
-for (nota in notas) {
-    suma += nota
-}
-return suma.toDouble() / notas.size
-```
-}
-fun main() {
-```
-val notas = arrayOf(7, 8, 6, 9)
-val media = calcularMedia(notas)
-println("Notas:")
-for (nota in notas) {
-    println(nota)
-}
-println("Media: $media")
-```
-} </code>
-Este ejemplo introduce una idea muy importante:
-> Las funciones permiten encapsular una operación para poder utilizarla desde diferentes lugares del programa.
-===== 35. Práctica final =====
-Crear un programa para gestionar las notas de un alumno.
-El programa debe:
-* Guardar el nombre del alumno.
-* Guardar sus notas en un array.
-* Mostrar todas las notas.
-* Calcular la suma de las notas.
-* Calcular la media.
-* Indicar si está aprobado o suspenso.
-El programa debe utilizar obligatoriamente:
-* `val`
-* `var`
-* `Array`
-* `for`
-* funciones
-* `if`
-* operadores aritméticos
-* interpolación de Strings
-==== Ampliación ====
-Modificar el programa para mostrar además:
-* Nota máxima.
-* Nota mínima.
-* Número de aprobados.
-* Número de suspensos.
-===== 36. Ejercicios de repaso =====
-=== Ejercicio 21 — Número positivo ===
-Pide un número y determina si es positivo, negativo o cero.
-=== Ejercicio 22 — Par o impar ===
-Pide un número y determina si es par o impar.
-=== Ejercicio 23 — Mayor de tres números ===
-Pide tres números y muestra cuál es el mayor.
-=== Ejercicio 24 — Calculadora ===
-Crea una calculadora sencilla.
-Debe recibir:
-* Dos números.
-* Una operación (`+`, `-`, `*`, `/`).
-Utiliza `when` para seleccionar la operación.
-=== Ejercicio 25 — Tabla de multiplicar ===
-Pide un número y muestra su tabla de multiplicar del 1 al 10.
-=== Ejercicio 26 — Contador ===
-Muestra los números del 1 al 100.
-Después modifica el programa para mostrar solamente los múltiplos de 5.
-=== Ejercicio 27 — Array de notas ===
-Crea un array con 10 notas.
-Calcula:
-* La media.
-* La nota máxima.
-* La nota mínima.
-* Cuántas notas están aprobadas.
-=== Ejercicio 28 — Funciones matemáticas ===
-Crea las siguientes funciones:
-<code>
-esPar(numero)
-esPositivo(numero)
-calcularMedia(notas)
-obtenerMaximo(notas)
-obtenerMinimo(notas)
-</code>
-Utiliza estas funciones desde `main()`.
-===== 37. Práctica final del tema =====
-Crear un programa de gestión básica de alumnos.
-El programa debe almacenar información de varios alumnos utilizando arrays.
-Para cada alumno se debe disponer de:
-<code>
-nombre
-edad
-nota
-</code>
-El programa debe mostrar un menú:
-<code>
-. Mostrar alumnos
-. Mostrar aprobados
-. Mostrar suspensos
-. Calcular nota media
-. Salir
-</code>
-Utilizar `when` para procesar las opciones.
-El programa debe utilizar:
-* Variables.
-* Tipos básicos.
-* Arrays.
-* `if`.
-* `when`.
-* `while`.
-* `for`.
-* Funciones.
-* Operadores.
-* Strings.
-* Rangos cuando sean necesarios.
-===== 38. Resumen de sintaxis =====
-==== Variables ====
-<code kotlin>
-val nombre = "Ana"
-var edad = 20
-</code>
-==== Tipos explícitos ====
-<code kotlin>
-val edad: Int = 20
-val nombre: String = "Ana"
-val altura: Double = 1.80
-val activo: Boolean = true
-val letra: Char = 'A'
-</code>
-==== Salida ====
-<code kotlin>
-print("Hola")
-println("Hola")
-</code>
-==== Interpolación ====
-<code kotlin>
-println("Hola $nombre")
-println("El resultado es ${a + b}")
-</code>
-==== Conversión ====
-<code kotlin>
-numero.toInt()
-numero.toDouble()
-numero.toLong()
-numero.toFloat()
-</code>
-==== Condicional ====
-<code kotlin>
-if (condicion) {
-    // ...
-} else {
-    // ...
-}
-</code>
-==== when ====
-<code kotlin>
-when (valor) {
--> println("Uno")
--> println("Dos")
-    else -> println("Otro")
-}
-</code>
-==== while ====
-<code kotlin>
-while (condicion) {
-    // ...
-}
-</code>
-==== do...while ====
-<code kotlin>
-do {
-    // ...
-} while (condicion)
-</code>
-==== for ====
-<code kotlin>
-for (elemento in elementos) {
-    // ...
-}
-</code>
-==== Rangos ====
-<code kotlin>
-..10
-downTo 1
-..10 step 2
-..<10
-</code>
-==== Arrays ====
-<code kotlin>
-val numeros = arrayOf(10, 20, 30)
-println(numeros[0])
-numeros[0] = 100
-println(numeros.size) </code>
-==== Función ====
-<code kotlin>
-fun saludar() {
-    println("Hola")
-}
-</code>
-==== Función con parámetros ====
-<code kotlin>
-fun saludar(nombre: String) {
-    println("Hola $nombre")
-}
-</code>
-==== Función con retorno ====
-<code kotlin>
-fun sumar(a: Int, b: Int): Int {
-    return a + b
-}
-</code>
-==== Función de expresión única ====
-<code kotlin>
-fun sumar(a: Int, b: Int) = a + b
-</code>
-===== 39. Lo que debes dominar antes de continuar =====
-Antes de pasar a las siguientes características de Kotlin deberías poder escribir, sin consultar continuamente la sintaxis:
-  * Un programa con ''main()''.
-  * Variables con ''val''y ''var''.
-  * Variables con tipos explícitos.
-  * Strings e interpolación.
-  * Operaciones aritméticas.
-  * Comparaciones.
-  * Condiciones mediante ''if''.
-  * Selecciones mediante ''when''.
-* Bucles ''while''.
-* Bucles ''do-while''.
-* Bucles ''for''.
-* ''break'' y ''continue''.
-* Arrays.
-* Rangos.
-* Funciones con parámetros.
-* Funciones con valores de retorno.
-El objetivo no es memorizar toda la sintaxis, sino **ser capaz de resolver problemas sencillos utilizando estas herramientas**.
-===== 40. Mapa conceptual =====
-<code>
-KOTLIN
-│
-├── PROGRAMA
-│   └── main()
-│
-├── VARIABLES
-│   ├── val
-│   ├── var
-│   └── inferencia de tipos
-│
-├── TIPOS
-│   ├── Int
-│   ├── Long
-│   ├── Double
-│   ├── Float
-│   ├── Boolean
-│   ├── Char
-│   └── String
-│
-├── OPERADORES
-│   ├── aritméticos
-│   ├── asignación
-│   ├── comparación
-│   └── lógicos
-│
-├── CONTROL DE FLUJO
-│   ├── if
-│   ├── when
-│   ├── while
-│   ├── do...while
-│   ├── break
-│   └── continue
-│
-├── ARRAYS
-│   ├── crear
-│   ├── acceder
-│   ├── modificar
-│   └── recorrer
-│
-├── BUCLES
-│   ├── for
-│   └── rangos
-│
-└── FUNCIONES
-    ├── crear
-    ├── llamar
-    ├── parámetros
-    ├── retorno
-    ├── return
-    ├── valores por defecto
-    ├── argumentos con nombre
-    └── expresión única
-</code>