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.

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.

El programa más sencillo que podemos escribir en Kotlin es:

fun main() {
    println("Hola mundo")
}

Al ejecutarlo obtenemos:

Hola mundo

La función `main()` es el punto de entrada de nuestro programa.

fun main() {
 
} 

Todo lo que queramos ejecutar al comenzar el programa puede colocarse dentro de ella.

Por ejemplo:

fun main() {
    println("Inicio del programa")
 
```
println("Fin del programa")
```
 
} 

Las llaves `{}` delimitan un bloque de código.

fun main() {
    println("Primera instrucción")
    println("Segunda instrucción")
}

En Kotlin no es necesario utilizar `;` al final de las instrucciones.

Correcto:

println("Hola")
println("Adiós")

Aunque el lenguaje permite utilizar punto y coma, no es habitual hacerlo.

Crea un programa que muestre por pantalla:

Bienvenido a Kotlin
Estoy aprendiendo programación
Este es mi primer programa

Kotlin utiliza una sintaxis relativamente sencilla y concisa.

Por ejemplo:

val nombre = "Ana"
val edad = 20
 
println("Nombre: $nombre")
println("Edad: $edad") 

No es necesario indicar siempre explícitamente el tipo de una variable.

Kotlin puede deducirlo automáticamente.

Kotlin distingue entre mayúsculas y minúsculas.

Por ejemplo:

val nombre = "Ana"
val Nombre = "Luis"

`nombre` y `Nombre` son identificadores diferentes.

Por convenio, debemos utilizar nombres descriptivos y seguir la nomenclatura habitual:

val nombreAlumno = "Ana"
val numeroDeAlumnos = 25

Se recomienda utilizar camelCase para variables y funciones.

Los comentarios permiten añadir explicaciones al código que no serán ejecutadas.

// Este es un comentario
 
val edad = 20 

También pueden colocarse al final de una instrucción:

val edad = 20 // Edad del alumno

/*
    Este comentario ocupa
    varias líneas.
*/

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.

Kotlin proporciona principalmente dos funciones para mostrar información:

* `print()` * `println()`

`println()` muestra información y después realiza un salto de línea.

println("Hola")
println("Mundo")

Resultado:

Hola
Mundo

`print()` muestra información pero no realiza un salto de línea.

print("Hola ")
print("Mundo")

Resultado:

Hola Mundo

val nombre = "Ana"
 
println(nombre) 

También podemos combinar texto y variables.

val nombre = "Ana"
val edad = 20
 
println("Nombre: $nombre")
println("Edad: $edad") 

Esto se denomina interpolación de cadenas.

Una variable permite almacenar un valor en memoria.

En Kotlin utilizamos principalmente dos palabras clave:

val
var

Una variable declarada mediante `val` no puede ser reasignada después de su inicialización.

val nombre = "Ana"

Esto produciría un error:

val nombre = "Ana"
 
nombre = "Luis" 

Una vez asignado `“Ana”`, no podemos asignar otro valor a `nombre`.

Una variable declarada mediante `var` sí puede cambiar de valor.

var edad = 20
 
edad = 21
edad = 22 

Como regla general:

Utiliza `val` por defecto y utiliza `var` solamente cuando necesites cambiar el valor.

Ejemplo:

val nombre = "Ana"
val fechaNacimiento = 2005
 
var edad = 20
edad = 21 

`nombre` y `fechaNacimiento` no necesitan ser reasignadas.

`edad`, en cambio, sí cambia.

Kotlin puede deducir el tipo de una variable a partir del valor que almacenamos.

val edad = 20
val nombre = "Ana"
val altura = 1.75
val activo = true

Kotlin deduce:

edad    → Int
nombre  → String
altura  → Double
activo  → Boolean

Esto se denomina inferencia de tipos.

También podemos indicar el tipo:

val edad: Int = 20
val nombre: String = "Ana"
val altura: Double = 1.75
val activo: Boolean = true

La sintaxis es:

val nombreVariable: Tipo = valor

o:

var nombreVariable: Tipo = valor

Normalmente:

val edad = 20

es preferible a:

val edad: Int = 20

cuando el tipo resulta evidente.

Sin embargo, indicar explícitamente el tipo puede mejorar la claridad en determinadas situaciones.

Confundir `val` con una constante absoluta.

val numeros = arrayOf(1, 2, 3)
 
numeros[0] = 10 

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.

Declara las siguientes variables utilizando inferencia de tipos:

* Nombre: `“Carlos”` * Edad: `21` * Altura: `1.82` * Es estudiante: `true`

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.

Kotlin dispone de diferentes tipos de datos.

Los más importantes en esta primera etapa son:

`Int` es el tipo que utilizaremos normalmente para números enteros.

val edad = 20
val numeroAlumnos = 25
val temperatura = -5

También podemos indicarlo explícitamente:

val edad: Int = 20

`Long` permite trabajar con números enteros de mayor tamaño.

val poblacion: Long = 48000000

Podemos utilizar `L` para indicar explícitamente un literal `Long`:

val numero = 48000000L

`Double` es el tipo decimal que utilizaremos habitualmente.

val altura = 1.82
val precio = 19.95

También podemos indicar el tipo:

val altura: Double = 1.82

Para utilizar `Float` debemos añadir normalmente `f` al número:

val temperatura: Float = 23.5f

En la mayoría de los programas utilizaremos `Double` salvo que necesitemos específicamente `Float`.

Un `Boolean` solamente puede tener dos valores:

true
false

Ejemplo:

val mayorDeEdad = true
val tieneCarnet = false

Los booleanos son especialmente importantes para las estructuras condicionales.

val edad = 20
 
if (edad >= 18) {
println("Es mayor de edad")
} 

`Char` representa un único carácter.

val letra: Char = 'A'

Los caracteres se escriben entre comillas simples.

'A'
'7'
'?'

No debemos confundir:

val letra = 'A'
val texto = "A"

`letra` es `Char`, mientras que `texto` es `String`.

`String` representa una cadena de caracteres.

val nombre = "Ana"
val ciudad = "León"

Los textos se escriben entre comillas dobles.

Kotlin permite introducir variables directamente dentro de un `String`.

val nombre = "Ana"
val edad = 20
 
println("Me llamo $nombre y tengo $edad años") 

También podemos utilizar expresiones:

println("El año que viene tendré ${edad + 1} años")

Podemos utilizar tres comillas dobles:

val texto = """
    Primera línea
    Segunda línea
    Tercera línea
""".trimIndent()

Kotlin no realiza automáticamente todas las conversiones numéricas.

Por ejemplo:

val numero: Int = 10
val decimal: Double = numero

No debemos asumir que esta conversión se realizará automáticamente.

Utilizaremos funciones como:

toByte()
toShort()
toInt()
toLong()
toFloat()
toDouble()

Ejemplo:

val numero = 10
 
val decimal = numero.toDouble() 

Otro ejemplo:

val numero = 10.8
 
val entero = numero.toInt()
 
println(entero) 

Resultado:

10

Crea un programa que:

* Declare un número entero. * Lo convierta a `Double`. * Muestre ambos valores.

Los operadores permiten realizar operaciones con datos.

Ejemplo:

val a = 10
val b = 3
 
println(a + b)
println(a - b)
println(a * b)
println(a / b)
println(a % b) 

Si dividimos dos `Int`, obtenemos un `Int`.

val resultado = 10 / 3
 
println(resultado) 

Resultado:

3

Si queremos obtener un resultado decimal:

val resultado = 10.0 / 3.0
 
println(resultado) 

El operador `%` devuelve el resto de una división.

println(10 % 3)

Resultado:

1

Es muy útil para determinar si un número es par:

val numero = 8
 
if (numero % 2 == 0) {
println("Es par")
} 

Asignación:

var puntos = 10
 
puntos = 20 

También podemos utilizar operadores abreviados:

puntos += 5
puntos -= 5
puntos *= 2
puntos /= 2
puntos %= 2

Por ejemplo:

var puntos = 10
 
puntos += 5 

equivale a:

puntos = puntos + 5

Podemos incrementar una variable:

var contador = 0
 
contador++ 

También podemos utilizar:

contador--

Son especialmente habituales en bucles.

Los principales operadores son:

Ejemplo:

val edad = 20
 
println(edad >= 18) 

Resultado:

true

`=` se utiliza para asignar:

var edad = 20
edad = 21

`==` se utiliza para comparar:

if (edad == 21) {
    println("Tiene 21 años")
}

`&&` devuelve `true` cuando ambas condiciones son verdaderas.

val edad = 20
val tieneCarnet = true
 
if (edad >= 18 && tieneCarnet) {
println("Puede conducir")
} 

`||` devuelve `true` cuando al menos una condición es verdadera.

val esSabado = true
val esDomingo = false
 
if (esSabado || esDomingo) {
println("Es fin de semana")
} 

`!` invierte el valor lógico.

val activo = true
 
println(!activo) 

Resultado:

false

Las cadenas de texto son uno de los tipos que más utilizaremos en una aplicación.

Podemos utilizar `+`:

val nombre = "Ana"
val apellido = "García"
 
val nombreCompleto = nombre + " " + apellido 

Sin embargo, normalmente resulta más cómodo utilizar interpolación:

val nombreCompleto = "$nombre $apellido"

Podemos obtener la longitud utilizando `length`:

val nombre = "Kotlin"
 
println(nombre.length) 

Resultado:

6

Podemos acceder a un carácter mediante su posición:

val nombre = "Kotlin"
 
println(nombre[0])
println(nombre[1]) 

Resultado:

K
o

Como ocurre con los arrays, los índices comienzan en `0`.

Crea un programa que:

* Guarde tu nombre en una variable. * Muestre el nombre. * Muestre cuántos caracteres tiene. * Muestre su primer carácter.

Las estructuras condicionales permiten ejecutar diferentes instrucciones dependiendo de una condición.

Sintaxis:

if (condicion) {
    // instrucciones
}

Ejemplo:

val edad = 20
 
if (edad >= 18) {
println("Mayor de edad")
} 

val edad = 16
 
if (edad >= 18) {
println("Mayor de edad")
} else {
println("Menor de edad")
} 

Podemos comprobar varias condiciones:

val nota = 7
 
if (nota >= 9) {
println("Sobresaliente")
} else if (nota >= 7) {
println("Notable")
} else if (nota >= 5) {
println("Aprobado")
} else {
println("Suspenso")
} 

Una característica importante de Kotlin es que `if` puede devolver un valor.

val edad = 20
 
val mensaje = if (edad >= 18) {
"Mayor de edad"
} else {
"Menor de edad"
}
 
println(mensaje) 

También podemos escribirlo de forma más compacta:

val mensaje = if (edad >= 18) "Mayor de edad" else "Menor de edad"

En Kotlin no necesitamos utilizar el operador ternario que existe en otros lenguajes.

Crea un programa que indique si un número es positivo, negativo o cero.

Crea un programa que reciba una edad y muestre:

* Menor de edad. * Adulto. * Mayor de 65 años.

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` permite seleccionar una opción entre diferentes posibilidades.

Es conceptualmente parecido a `switch` en otros lenguajes.

Sintaxis:

when (valor) {
    valor1 -> instrucciones
    valor2 -> instrucciones
    else -> instrucciones
}

Ejemplo:

val dia = 3
 
when (dia) {
1 -> println("Lunes")
2 -> println("Martes")
3 -> println("Miércoles")
4 -> println("Jueves")
5 -> println("Viernes")
6 -> println("Sábado")
7 -> println("Domingo")
else -> println("Día incorrecto")
} 

Podemos agrupar varios valores:

val dia = 6
 
when (dia) {
1, 2, 3, 4, 5 -> println("Día laborable")
6, 7 -> println("Fin de semana")
else -> println("Día incorrecto")
} 

`when` también puede devolver un valor.

val nota = 8
 
val resultado = when (nota) {
10 -> "Matrícula"
9 -> "Sobresaliente"
7, 8 -> "Notable"
5, 6 -> "Aprobado"
else -> "Suspenso"
}
 
println(resultado) 

También podemos utilizar `when` para evaluar condiciones:

val edad = 25
 
when {
edad < 18 -> println("Menor de edad")
edad < 65 -> println("Adulto")
else -> println("Mayor de 65")
} 

Como regla práctica:

* Utiliza `if` cuando tengas que comprobar una condición o pocas condiciones. * Utiliza `when` cuando tengas diferentes posibilidades claramente diferenciadas.

Crea un programa que reciba un número del 1 al 12 y muestre el mes correspondiente.

Crea un programa que reciba una opción de menú:

1 → Alta
2 → Baja
3 → Modificar
4 → Consultar

Utiliza `when`.

Los bucles permiten repetir instrucciones.

`while` repite un bloque mientras una condición sea verdadera.

Sintaxis:

while (condicion) {
    // instrucciones
}

Ejemplo:

var contador = 1
 
while (contador <= 5) {
println(contador)
contador++
} 

Resultado:

1
2
3
4
5

Debemos asegurarnos de que la condición pueda llegar a ser falsa.

Incorrecto:

var contador = 1
 
while (contador <= 5) {
println(contador)
} 

`contador` nunca cambia, por lo que la condición siempre será verdadera.

Correcto:

var contador = 1
 
while (contador <= 5) {
println(contador)
contador++
} 

La estructura `do…while` ejecuta el bloque antes de comprobar la condición.

var contador = 1
 
do {
println(contador)
contador++
} while (contador <= 5) 

La principal diferencia es:

while
    → comprueba primero

do...while
→ ejecuta primero y comprueba después 

Por tanto, un `do…while` ejecuta su cuerpo al menos una vez.

Crea un programa que muestre los números del 10 al 1 utilizando `while`.

`break` termina inmediatamente el bucle.

var contador = 1
 
while (contador <= 10) {
 
```
if (contador == 5) {
    break
}
 
println(contador)
contador++
```
 
} 

Resultado:

1
2
3
4

`continue` termina la iteración actual y pasa a la siguiente.

var contador = 0
 
while (contador < 5) {
 
```
contador++
 
if (contador == 3) {
    continue
}
 
println(contador)
```
 
} 

Resultado:

1
2
4
5

Crea un programa que recorra los números del 1 al 20 y muestre solamente los números pares.

Hazlo utilizando `continue`.

Un array permite almacenar varios elementos.

Se puede crear mediante `arrayOf()`:

val numeros = arrayOf(10, 20, 30, 40, 50)

Los elementos están indexados comenzando por `0`.

Índice:    0    1    2    3    4
Valor:    10   20   30   40   50

val numeros = arrayOf(10, 20, 30)
 
println(numeros[0])
println(numeros[1])
println(numeros[2]) 

Podemos modificar un elemento:

val numeros = arrayOf(10, 20, 30)
 
numeros[0] = 100 

Ahora el array contiene:

100, 20, 30

Utilizamos `size`:

val numeros = arrayOf(10, 20, 30, 40)
 
println(numeros.size) 

Resultado:

4

val nombres = arrayOf("Ana", "Luis", "Marta")

Podemos acceder a sus elementos:

println(nombres[0])

Podemos utilizar `in`:

val nombres = arrayOf("Ana", "Luis", "Marta")
 
if ("Luis" in nombres) {
println("Luis está en el array")
} 

No podemos acceder a una posición que no existe.

val numeros = arrayOf(10, 20, 30)
 
println(numeros[3]) 

El último índice válido es `2`.

Los índices van de:

0 hasta size - 1

Crea un array con cinco nombres.

Muestra:

* El primer nombre. * El último nombre. * El número de elementos.

`for` permite recorrer elementos de una colección o un rango.

Ejemplo:

val nombres = arrayOf("Ana", "Luis", "Marta")
 
for (nombre in nombres) {
println(nombre)
} 

Resultado:

Ana
Luis
Marta

for (numero in 1..5) {
    println(numero)
}

Los caracteres de una cadena también pueden recorrerse:

val nombre = "Kotlin"
 
for (letra in nombre) {
println(letra)
} 

Podemos utilizar `indices`:

val nombres = arrayOf("Ana", "Luis", "Marta")
 
for (i in nombres.indices) {
println(nombres[i])
} 

También podemos obtener índice y valor mediante `withIndex()`:

for ((indice, nombre) in nombres.withIndex()) {
    println("$indice: $nombre")
}

Crea un array de cinco números y utiliza un `for` para calcular la suma de todos ellos.

Kotlin dispone de una sintaxis específica para crear rangos.

1..5

Representa:

1, 2, 3, 4, 5

Ejemplo:

for (i in 1..5) {
    println(i)
}

Utilizamos `downTo`:

for (i in 5 downTo 1) {
    println(i)
}

Resultado:

5
4
3
2
1

for (i in 0..10 step 2) {
    println(i)
}

Resultado:

0
2
4
6
8
10

Podemos utilizar `..<`:

for (i in 1..<5) {
    println(i)
}

Resultado:

1
2
3
4

Esto resulta especialmente útil para trabajar con índices.

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.

Una función es un bloque de código que realiza una tarea concreta.

Las funciones se declaran mediante la palabra clave `fun`.

fun saludar() {
    println("Hola")
}

Para ejecutar la función:

saludar()

Programa completo:

fun saludar() {
    println("Hola")
}
 
fun main() {
saludar()
} 

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:

println("Bienvenido")
println("Bienvenido")
println("Bienvenido")

podemos crear:

fun mostrarBienvenida() {
    println("Bienvenido")
}
 
fun main() {
mostrarBienvenida()
mostrarBienvenida()
mostrarBienvenida()
} 

Una función puede recibir información mediante parámetros.

fun saludar(nombre: String) {
    println("Hola $nombre")
}

Podemos llamarla:

saludar("Ana")
saludar("Luis")

Resultado:

Hola Ana
Hola Luis

fun presentar(nombre: String, edad: Int) {
    println("$nombre tiene $edad años")
}

Llamada:

presentar("Ana", 20)

Cada parámetro tiene:

nombre: Tipo

Por ejemplo:

nombre: String
edad: Int
altura: Double

Una función puede devolver un valor.

fun sumar(a: Int, b: Int): Int {
    return a + b
}

La parte:

: Int

indica que la función devuelve un `Int`.

Podemos guardar el resultado:

val resultado = sumar(10, 20)
 
println(resultado) 

Resultado:

30

La palabra `return` indica qué valor devuelve la función.

fun multiplicar(a: Int, b: Int): Int {
    return a * b
}

Una función que no devuelve un valor útil puede escribirse:

fun mostrarMensaje() {
    println("Hola")
}

Internamente su retorno es `Unit`, pero normalmente no necesitamos escribirlo.

También podríamos escribir:

fun mostrarMensaje(): Unit {
    println("Hola")
}

pero la primera forma es la habitual.

Cuando una función solamente tiene una expresión podemos utilizar una sintaxis abreviada.

En lugar de:

fun sumar(a: Int, b: Int): Int {
    return a + b
}

podemos escribir:

fun sumar(a: Int, b: Int): Int = a + b

Incluso podemos dejar que Kotlin deduzca el tipo de retorno:

fun sumar(a: Int, b: Int) = a + b

Otro ejemplo:

fun cuadrado(numero: Int) = numero * numero

Esta sintaxis es habitual en Kotlin.

Podemos proporcionar un valor por defecto a un parámetro.

fun saludar(nombre: String = "usuario") {
    println("Hola $nombre")
}

Ahora podemos hacer:

saludar()

Resultado:

Hola usuario

También podemos proporcionar nuestro propio valor:

saludar("Ana")

Resultado:

Hola Ana

Podemos indicar explícitamente qué parámetro estamos proporcionando:

fun presentar(nombre: String, edad: Int) {
    println("$nombre tiene $edad años")
}
 
presentar(nombre = "Ana", edad = 20) 

También podemos cambiar el orden:

presentar(edad = 20, nombre = "Ana")

Esto puede hacer que las llamadas a funciones sean más fáciles de leer.

Crea una función:

saludar()

que muestre un saludo.

Crea una función:

saludar(nombre)

que reciba un nombre y muestre:

Hola, nombre

Crea una función `sumar()` que reciba dos números enteros y devuelva su suma.

Crea las siguientes funciones:

restar()
multiplicar()
dividir()

Cada función debe recibir dos números y devolver el resultado correspondiente.

Crea una función que reciba una edad y devuelva `true` si la persona es mayor de edad y `false` en caso contrario.

Desde el principio debemos acostumbrarnos a escribir código claro.

Evitar:

val x = 20
val y = "Ana"

Preferir:

val edad = 20
val nombre = "Ana"

Preferir:

val nombre = "Ana"

frente a:

var nombre = "Ana"

si no necesitamos modificar la variable.

Una función debería realizar una tarea concreta.

Evitar funciones enormes que hagan muchas cosas diferentes.

Por ejemplo:

fun calcularMedia(...)

debería encargarse de calcular una media.

Otra función:

fun mostrarResultado(...)

puede encargarse de mostrar el resultado.

Si escribimos varias veces el mismo código, probablemente podamos convertirlo en una función.

El siguiente programa combina variables, tipos, operadores y condicionales.

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")
}
```
 
} 

Podemos mejorar el programa anterior separando responsabilidades.

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(
    7.0,
    8.0,
    6.0
)
 
val resultado = obtenerResultado(media)
 
println("Alumno: $nombre")
println("Media: $media")
println("Resultado: $resultado")
```
 
} 

Aquí estamos utilizando:

* Variables. * `val`. * `Double`. * Operadores aritméticos. * `if`. * `String`. * Interpolación. * Funciones. * Parámetros. * Valores de retorno. * `return`.

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")
```
 
} 

Este ejemplo introduce una idea muy importante:

Las funciones permiten encapsular una operación para poder utilizarla desde diferentes lugares del programa.

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

Modificar el programa para mostrar además:

* Nota máxima. * Nota mínima. * Número de aprobados. * Número de suspensos.

Pide un número y determina si es positivo, negativo o cero.

Pide un número y determina si es par o impar.

Pide tres números y muestra cuál es el mayor.

Crea una calculadora sencilla.

Debe recibir:

* Dos números. * Una operación (`+`, `-`, `*`, `/`).

Utiliza `when` para seleccionar la operación.

Pide un número y muestra su tabla de multiplicar del 1 al 10.

Muestra los números del 1 al 100.

Después modifica el programa para mostrar solamente los múltiplos de 5.

Crea un array con 10 notas.

Calcula:

* La media. * La nota máxima. * La nota mínima. * Cuántas notas están aprobadas.

Crea las siguientes funciones:

esPar(numero)
esPositivo(numero)
calcularMedia(notas)
obtenerMaximo(notas)
obtenerMinimo(notas)

Utiliza estas funciones desde `main()`.

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:

nombre
edad
nota

El programa debe mostrar un menú:

1. Mostrar alumnos
2. Mostrar aprobados
3. Mostrar suspensos
4. Calcular nota media
5. Salir

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.

val nombre = "Ana"
var edad = 20

val edad: Int = 20
val nombre: String = "Ana"
val altura: Double = 1.80
val activo: Boolean = true
val letra: Char = 'A'

print("Hola")
println("Hola")

println("Hola $nombre")
println("El resultado es ${a + b}")

numero.toInt()
numero.toDouble()
numero.toLong()
numero.toFloat()

if (condicion) {
    // ...
} else {
    // ...
}

when (valor) {
    1 -> println("Uno")
    2 -> println("Dos")
    else -> println("Otro")
}

while (condicion) {
    // ...
}

do {
    // ...
} while (condicion)

for (elemento in elementos) {
    // ...
}

1..10
10 downTo 1
1..10 step 2
1..<10

val numeros = arrayOf(10, 20, 30)
 
println(numeros[0])
 
numeros[0] = 100
 
println(numeros.size) 

fun saludar() {
    println("Hola")
}

fun saludar(nombre: String) {
    println("Hola $nombre")
}

fun sumar(a: Int, b: Int): Int {
    return a + b
}

fun sumar(a: Int, b: Int) = a + b

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 valy 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.

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