Diferencias

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

--- bloque2:juegos [2026/09/08 23:08] – fernando
+++ bloque2:juegos [2026/09/11 12:30] (actual) – borrado fernando
@@ Línea 1: / Línea 1: @@
-====== Fundamentos del lenguaje Kotlin ======
-===== 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.
-===== Contenidos =====
-Mediante esta guía se pretende alcanzar los conocimientos necesarios para:
-  * 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.
-===== 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>
-==== 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>
-==== Las llaves ====
-Las llaves ''{}'' delimitan un bloque de código.
-<code kotlin>
-fun main() {
-    println("Primera instrucción")
-    println("Segunda instrucción")
-}
-</code>
-==== 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>
-===== 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.
-==== 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.
-===== Comentarios =====
-Los comentarios permiten añadir explicaciones al código que no serán ejecutadas.
-==== 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>
-==== 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.
-===== 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>
-==== 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>
-==== 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**.
-===== Variables =====
-Una variable permite almacenar un valor en memoria.
-En Kotlin utilizamos principalmente dos palabras clave:
-  * val
-  * var
-==== 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''.
-==== var ====
-Una variable declarada mediante ''var'' sí puede cambiar de valor.
-<code kotlin>
-var edad = 20
-edad = 21
-edad = 22 </code>
-==== ¿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.
-==== 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**.
-==== 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 kotlin>
-val nombreVariable: Tipo = valor
-</code>
-ó
-<code kotlin>
-var nombreVariable: Tipo = valor
-</code>
-==== ¿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.
-===== 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 |
-===== Números enteros =====
-==== 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>
-==== 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>
-===== Números decimales =====
-==== 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>
-==== 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>
-===== 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''.
-===== String =====
-''String'' representa una cadena de caracteres.
-<code kotlin>
-val nombre = "Ana"
-val ciudad = "León"
-</code>
-Los textos se escriben entre comillas dobles.
-==== 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>
-==== Cadenas multilínea ====
-Podemos utilizar tres comillas dobles:
-<code kotlin>
-val texto = """
-    Primera línea
-    Segunda línea
-    Tercera línea
-""".trimIndent()
-</code>
-===== 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.
-===== Operadores =====
-Los operadores permiten realizar operaciones con datos.
-===== 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>
-==== 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>
-==== 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>
-===== 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>
-===== 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.
-===== 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>
-===== 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>
-==== 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>
-==== NOT ====
-''!'' invierte el valor lógico.
-<code kotlin>
-val activo = true
-println(!activo) </code>
-Resultado:
-<code>
-false
-</code>
-===== 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>
-==== Longitud de una cadena ====
-Podemos obtener la longitud utilizando ''length'':
-<code kotlin>
-val nombre = "Kotlin"
-println(nombre.length) </code>
-Resultado:
-<code>
-</code>
-==== 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.
-===== if =====
-Sintaxis:
-<code kotlin>
-if (condicion) {
-    // instrucciones
-}
-</code>
-Ejemplo:
-<code kotlin>
-val edad = 20
-if (edad >= 18) {
-println("Mayor de edad")
-} </code>
-=====  if-else =====
-<code kotlin>
-val edad = 16
-if (edad >= 18) {
-println("Mayor de edad")
-} else {
-println("Menor de edad")
-} </code>
-===== 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>
-===== 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
-=====  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>
-====  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>
-====  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>
-====  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''.
-===== 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>
-=====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>
-=====  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''.
-===== 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>
-===== 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''.
-=====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>
-=====  Acceder a elementos =====
-<code kotlin>
-val numeros = arrayOf(10, 20, 30)
-println(numeros[0])
-println(numeros[1])
-println(numeros[2]) </code>
-=====  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>
-===== Tamaño de un array =====
-Utilizamos ''size'':
-<code kotlin>
-val numeros = arrayOf(10, 20, 30, 40)
-println(numeros.size) </code>
-Resultado:
-<code>
-</code>
-=====  Arrays de Strings =====
-<code kotlin>
-val nombres = arrayOf("Ana", "Luis", "Marta")
-</code>
-Podemos acceder a sus elementos:
-<code kotlin>
-println(nombres[0])
-</code>
-=====  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>
-=====  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.
-=====  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>
-=====  Recorrer números =====
-<code kotlin>
-for (numero in 1..5) {
-    println(numero)
-}
-</code>
-=====  Recorrer un String =====
-Los caracteres de una cadena también pueden recorrerse:
-<code kotlin>
-val nombre = "Kotlin"
-for (letra in nombre) {
-println(letra)
-} </code>
-===== Í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.
-=====  Rangos =====
-Kotlin dispone de una sintaxis específica para crear rangos.
-=====  Rango ascendente =====
-<code kotlin>
-..5
-</code>
-Representa:
-<code>
-, 2, 3, 4, 5
-</code>
-Ejemplo:
-<code kotlin>
-for (i in 1..5) {
-    println(i)
-}
-</code>
-=====  Rango descendente =====
-Utilizamos ''downTo'':
-<code kotlin>
-for (i in 5 downTo 1) {
-    println(i)
-}
-</code>
-Resultado:
-<code>
-</code>
-=====  Saltos mediante step =====
-<code kotlin>
-for (i in 0..10 step 2) {
-    println(i)
-}
-</code>
-Resultado:
-<code>
-</code>
-=====  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.
-=====  Funciones =====
-Una función es un bloque de código que realiza una tarea concreta.
-Las funciones se declaran mediante la palabra clave ''fun''.
-=====  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>
-===== ¿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>
-=====  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>
-===== 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>
-=====  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>
-=====  return =====
-La palabra ''return'' indica qué valor devuelve la función.
-<code kotlin>
-fun multiplicar(a: Int, b: Int): Int {
-    return a * b
-}
-</code>
-=====  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.
-=====  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.
-===== 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>
-=====  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.
-=====  Buenas prácticas =====
-Desde el principio debemos acostumbrarnos a escribir código claro.
-====  Utilizar nombres descriptivos ====
-Evitar:
-<code kotlin>
-val x = 20
-val y = "Ana"
-</code>
-Preferir:
-<code kotlin>
-val edad = 20
-val nombre = "Ana"
-</code>
-====  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.
-==== 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.
-==== Evitar repetir código ====
-Si escribimos varias veces el mismo código, probablemente podamos convertirlo en una función.
-=====  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>
-===== 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''.
-=====  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.
-===== 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.
-=====  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()''.
-===== 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.
-===== 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>
-=====  Conclusiones =====
-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**.
-=====  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>