Kotlin es un lenguaje de programación moderno desarrollado por JetBrains y su primera versión estable fue liberada en 2016. Es un lenguaje de propósito general por lo que se puede utilizar para crear aplicaciones para muchos ámbitos.

Aunque puede utilizarse para diferentes tipos de aplicaciones, tiene especial importancia en el desarrollo de aplicaciones para Android, y en 2019 Google establece este lenguaje como el lenguaje oficial para desarrollo en Android.

En este tema aprenderemos los fundamentos necesarios para comenzar a programar en Kotlin y utilizarlos posteriormente en el desarrollo de aplicaciones Android.

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

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

Comentarios de una línea

// Este es un comentario
 
val edad = 20 

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

val edad = 20 // Edad del alumno

Comentarios de varias líneas

/*
    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.

Al igual que en otros lenguajes, Kotlin tiene instrucciones para mostrar datos por consola, y leer datos del usuario.

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.

Kotlin es un lenguaje de propósito general y también tiene sentencias para leer desde la entrada standard.

La función readln() lee una linea completa desde teclado y la almacena como un String.

println("Introduce nombre y apellidos")
val nombre = readln()

Como tipo de datos devuelto por la función readln() es un String, para obtener otro tipo de dato (p.e. un número) debo realizar conversiones de tipos, como veremos más adelante.

println("Introduce un numero")
 
val numero : Int = readln().toInt()

Una variable permite almacenar un valor en memoria. En Kotlin utilizamos principalmente dos palabras clave para declararlas:

• val
• var

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

val nombre = "Ana"
 
//La siguiente instrucción produce un error:
nombre = "Luis" 

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

var: 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 sí puede cambiar.

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.

Kotlin puede deducir el tipo de una variable a partir del valor que almacenamos. Una vez que una variable define su tipo de datos, no podrá cambiar de tipo.

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 de datos en la declaración:

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

La sintaxis es:

val nombreVariable: Tipo 
var nombreVariable: Tipo 

• Las variables solo pueden usarse después de inicializarlas.
• Se puede inicializar una variable en el momento de declararla, o declararla primero y posteriormente inicializarla.
• En caso de declararla para inicializarla posteriormente, debo siempre indicar el tipo.

//Declaro e inicializo
val num1 = 5
 
//Declaro y después inicializo (debo indicar el tipo)
val num2 : Int
 
num2 = 26

Si el tipo resulta evidente, no se indicará, sin embargo, indicar explícitamente el tipo puede mejorar la claridad en determinadas situaciones.

val edad = 20

es preferible a:

val edad: Int = 20

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, pero todo se trata como un objeto, lo que significa que podemos llamar a funciones miembro y acceder a propiedades sobre cualquier tipo de datos.

Al ser un lenguaje de tipado estático, el tipo de datos de cada expresión debe conocerse en tiempo de compilación.

Dentro de los datos numéricos podemos diferenciar entre:

• Valores enteros: Byte, Short, Int y Long
• Valores de coma flotante: Float y Double

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

Si no indicamos el tipo, Kotlin infiere el tipo como Int siempre que quepa en su rango.

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.

Sintetizando, podemos seguir las siguientes reglas para:

• Utiliza Int para números enteros.
• Utiliza Long para números enteros que estén fuera del rango de Int.
• Utiliza Double para números decimales.
• Utiliza Float cuando sea aceptable o necesaria una menor precisión.
• Utiliza Byte y Short cuando una API o un formato de datos lo requiera.

Un tipo Boolean solamente puede tener dos valores:

• true
• false

Se utiliza para funciones que solo devuelven si/no, o para condiciones de las sentencias if/else, while, etc

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 codificado como UTF-16.

val letter: Char = 'A'
 
val digit = '1'
val symbol = '!'
val space = ' '
val separator = ':'

Los caracteres se escriben entre comillas simples ' '. Si incluimos más caracteres el compilador nos indicará un error.

val letra = 'A'
 
//Incorrecto
val texto = "A"

letra es Char, mientras que texto es String.

Dispone de caracteres de escape, aquellos que son difíciles de escribir mediante lenguaje escrito:

Al igual que en otros lenguajes, hay algunas operaciones que permiten realizarse con tipos de datos Char, como si tuvieran un significado numérico:

• Comparaciones

val antes= 'a' < 'b' // true
val despues = 'c' > 'd' // false
val distinto = 'A' == 'a' // false
val igual = 'A' == 'A' // true

• Funciones: Revisar Api de Kotlin

val caracter = 'A'
// Comprueba si es un digito
println(caracter.isDigit()) // false
// Comprueba si es mayuscula
println(caracter.isUpperCase()) // true
// Devuelve el valor el minuscula
println(caracter.lowercaseChar()) // 'a'

• Operaciones aritméticas

val caracter = 'a'
 
println(a + 1)  // b
println(a + 2)  // c
println(a - 32) // A
 
var a = 'A'
 
a += 10
println(a)   // 'K'
println(++a) // 'L'  preincremento
println(a++) // 'L'  postincremento
println(a)   // 'M'

• El tipo String representa una cadena de caracteres.
• Los valores String son inmutables, esto quiero decir que después de crear un objeto su valor no cambia durante el resto de su existencia en el programa.
• Cualquier operación que parezca que modifica un String, está realmente creando uno nuevo.
• Los valores String se escriben entre comillas dobles.

val nombre: String= "Ana"
val ciudad = "León" //Infiere el tipo

Si queremos almacenar cadenas de texto compuestas de varias lineas, utilizaremos tres comillas dobles:

val texto = """
    Primera línea,
    Segunda línea,
    Tercera línea
"""

De esta forma se mantienen los saltos de linea o las tabulaciones.

Kotlin permite introducir el valor de variables directamente dentro de un String.

val nombre = "Ana"
val edad = 20
 
println("Me llamo $nombre y tengo $edad años") 
 
//Y con { } para expresiones
println("El año que viene tendré ${edad + 1} años")

Podemos utilizar + para unir diferentes Strings u otros tipos de datos:

val nombre = "Ana"
val apellido = "García"
val edad = 26
 
val nombreCompleto = nombre + " " + apellido + "tiene " + edad 

Podemos obtener la longitud (cantidad de caracteres) utilizando la propiedadlength:

val nombre = "Kotlin"
 
println(nombre.length) //muestra 6
 

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

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

Como ocurre con los arrays, los índices comienzan en 0 y si nos pasamos del length -1 obtendremos una excepcion StringIndexOutOfBoundException.

val text = "  Hola, Kotlin  "
 
println(text.trim())
// Hola, Kotlin
 
println(text.replace("Kotlin", "mundo"))
//   Hola, mundo
 
println(text.uppercase())
//   HOLA, KOTLIN  
 
println(text.lowercase())
//   hola, kotlin  
 
 
val dominio = "kotlinlang.org"
 
// Comprueba si contiene "."
println(dominio.contains("."))
// true
 
// Comprueba si empieza por "kotlin"
println(dominio.startsWith("kotlin"))
// true
 
// Comprueba si termina por ".org"
println(dominio.endsWith(".org"))
// true
 
 
val numeros = "uno, dos, tres"
println(numeros.split(", "))
// [uno, dos, tres]

Los arrays son una estructura de datosque contiene un numero fijo de valores del mismo tipo. Están ordenados y se acceden mediante un índice numérico.

• Función arrayOf()
• Función arrayOfNulls()
• Constructor Array<>()
• Arrays de tipos primitivos

Permite crear un array a partir de una serie de valores dados de antemano. Se especificará el tipo mediante inferencia de tipos:

val numeros = arrayOf(10, 20, 30, 40, 50) //array de Int
val nombres = arrayOf<String>("Ana", "Luis", "Marta") //array String

Crea un array de un tamaño concreto rellenado con valores ''null':

val nullArray = arrayOfNulls<String>(3)

Permite crear un array de un tipo concreto, asignando un valor inicial a sus celdas:

val nombres = Array<String>(5) {""} // Array de tamaño 5 con el valor ""
val numeros = Array<Int>(10) {0} // Array con el valor 0

Kotlin tiene una serie de constructores para crear arrays de tipos básicos:

val arrayEnteros = IntArray(5) //Crea un array con valores a 0
val arrayCaracteres = CharArray(10) // Crea un array con valores a 0

Tenemos los siguientes constructores: BooleanArray, ByteArray, CharArray, DoubleArray, FloatArray, IntArray, LongArray, ShortArray

Las posiciones de un array responden a un índice ordinal

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

Para acceder a cada una:

val numeros = arrayOf(10, 20, 30)
 
println(numeros[0])
println(numeros[1])
println(numeros[2]) 
 
numeros[0] = 100 // He modificado un valor

• Utilizamos size para conocer el tamaños:

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

• Podemos utilizar in para comprobar si contiene un valor

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

También dispones de la función contains()

Otras funciones o propiedades:

Conocido en otros lenguajes como matrices, son arrays de arrays, o arrays de 2 dimensiones:

val matriz = Array(2) { Array<Int>(2) { 0 } } // [[0, 0], [0, 0]]
matriz[0][1] = 25

Se modifican con 2 indices, y se recorren con dos bucles.

Crea un array con cinco nombres.

Muestra:

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

• Conversiones numéricas

Kotlin no realiza automáticamente todas las conversiones numéricas como podría ocurrir en otros lenguajes.

Por ejemplo:

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

Todos los tipos numéricos soportan conversiones a otros tipos numéricos pero debemos usar las siguientes funciones:

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

Ejemplo:

val numero = 10
val decimal = numero.toDouble() // 10.0
 
val numero = 10.8
val entero = numero.toInt()
println(entero) // 10

• Conversiones a String

Kotlin también ofrece mecanismos para transformar de otro tipo de datos a tipo String o viceversa:

val numero = 10
val texto = numbero.toString()
 
val textoDouble = "10.324"
val decimal = textoDouble.toDouble()

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, uno de los valores debe ser decimal:

val resultado = 10 / 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

var puntos = 10
puntos += 5 
 
// equivale a:
 
puntos = puntos + 5

Podemos incrementar y decrementar una variable:

var contador = 0
 
contador++
contador--

Son especialmente habituales en bucles.

Se utilizan para realizar comparaciones entre valores, y dan siempre como resultado un valor de tipo Boolean, es decir, true/false. Los principales operadores son:

Ejemplo:

val edad = 20
 
println(edad >= 18) 

Resultado:

true

Se utilizan para realizar operaciones entre valores de tipo Boolean y dan como resultado un valor de tipo Boolean.

&& 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) //false 

Crea un programa que:

• Guarde tu nombre en una variable.
• Muestre el nombre.
• Muestre cuántos caracteres tiene.
• Muestre su primer carácter y tercer carácter separados por un guión -.

Con estas estructuras modificamos el flujo de ejecución de un programa, es decir, podemos hacer que parte del código fuente escrito, se ejecute o no, o se repita varias veces. Estas sentencias son:

• sentencia if-else
• sentencia when
• bucle while
• bucle do-while
• bucle for

Sintaxis:

if (condicion) {
    // instrucciones
}
 
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"

Crea un programa que indique si un número es positivo, negativo o cero, y después si es par o impar.

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.

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")
                  println("Lunes a Viernes")
                  }
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.

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

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

var contador = 1
 
while (contador <= 5) {
   println(contador)
}
// Bucle infinito, la condición de salida no se modifica
 

La estructura do-while ejecuta el bloque al menos una vez y despues comprueba la condición.

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

La principal diferencia es:

• bucle while: Se ejecuta 0 ó más veces
• bucle do-while: Se ejecuta 1 o más veces

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++
```
 
} 

continue termina la iteración actual de un bucle y pasa a la siguiente.

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

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

El bucle for permite recorrer elementos de una colección, array o rango.

Ejemplo:

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

Resultado:

Ana
Luis
Marta

El bucle for se usa junto con los rangos para iterar sobre una serie de números.

// Rango ascendente del 1 al 6
for (i in 1..6) {
    print(i) // 123456
}
 //Rango ascendente sin llegar al límite superior (6)
for (i in 1..<6) {
    print(i) // 12345
}
 
// Rango descendente
for (i in 6 downTo 0 step 2) {
    print(i) // 6420
}

Los caracteres de una cadena también pueden recorrerse:

val nombre = "Kotlin"
 
for (letra in nombre) {
print("$letra ") // K o t l i n
} 

Podemos utilizar la propiedad indices:

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

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

Realiza los siguientes recorridos con el bucle for:

• 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")
}
 
// Ejecutamos mediante
fun main() {
    saludar()
} 

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

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

• En caso de varios parámetros, separamos con , :

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

• Para llamar a la función damos los valores de cada tipo en orden:

presentar("Ana", 20)

• Pero también podemos darlos en el orden que queramos si indicamos el nombre de la variable:

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

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

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

Ahora podemos hacer diferentes llamadas:

saludar()
 
saludar("Ana")

Una función puede devolver un valor. Debemos indicar el tipo de datos del valor que devuelve:

fun sumar(a: Int, b: Int): Int {
    return a + b
}
 
. . .
 
val resultado = sumar(10, 20)

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

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

• Tipo Unit

Una función que no tiene valor de retorno se puede escribir:

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

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

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

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

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.

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 que muestre un menú de texto con 3 opciones:

1- Introduce una cadena de texto
2- Introduce varias cadenas de texto
3- Salir

Después se le solicitará al usuario que introduzca un numero de opción y el programa la leerá. El menú se repetirá constantemente hasta seleccionar la opción 3.

La primera opción pedirá una cadena de texto, la leerá y mostrará por consola sus caracteres pero en orden inverso, desde el ultimo al primero separados por un espacio.

La segunda opción pedirá un valor numérico con la cantidad de cadenas a introducir, y acto seguido crea un array de Strings de esa cantidad de cadenas. Después pide al usuarios una a una las cadenas y las va almacenando en él. Al terminar de pedir la última, recorre el array mostrando todas las cadenas en la misma línea separadas por un espacio.

Después de terminar de ejecutar cada opción, se vuelve a repetir el menú, hasta que el usuario seleccione la opción 3.

Crear un programa en Kotlin para calcular unas estadísticas sobre las notas de los alumnos. El programa solicitará al usuario un valor entero con la cantidad de calificaciones a introducir. Posteriormente creará un array de ese tamaño y, pedirá y almacenará todas las calificaciones en él.

Al terminar, mostrará al usuario un menú, con las siguientes opciones:

1. Mostrar media aritmética
2. Mostrar la calificación más alta
3. Mostrar la calificación más baja
4. Mostrar la cantidad de aprobados
5. Mostrar la cantidad de suspensos
6. Terminar

Este menú se repetirá como en el programa anterior. Para el trabajo de recorrer el array buscando datos, trataremos de utilizar el bucle for

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.
• Nota máxima.
• Nota mínima.
• Número de aprobados.
• Número de suspensos.

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.

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

Crear un proyecto para Kotlin en AndroidStudio

© 2026 Fernando Valdeón