====== Fundamentos del lenguaje Kotlin ====== ===== Introducción a Kotlin ===== 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. {{ :anexos:jetbrains_logo.png?200|}} 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. {{ :anexos:kotlin-logo.png?200 |}} ===== Sintaxis principal ===== 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 ==== 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 === Las llaves ''{}'' delimitan un bloque de código. fun main() { println("Primera instrucción") println("Segunda instrucción") } === Punto y coma === 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. === Ejercicio 1 === Crea un programa que muestre por pantalla: Bienvenido a Kotlin Estoy aprendiendo programación Este es mi primer programa ==== Comentarios ==== 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. ===== Mostrar y leer información ===== Al igual que en otros lenguajes, Kotlin tiene instrucciones para mostrar datos por consola, y leer datos del usuario. ==== Mostrar información ==== Kotlin proporciona principalmente dos funciones para mostrar información: * ''print()'' * ''println()'' === println() === ''println()'' muestra información y después realiza un salto de línea. println("Hola") println("Mundo") Resultado: Hola Mundo === print() === ''print()'' muestra información pero no realiza un salto de línea. print("Hola ") print("Mundo") Resultado: Hola Mundo ==== Mostrar variables ==== 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**. ==== Leer información ==== 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() ===== Variables ===== 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. === Error frecuente === 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. ==== Inferencia de tipos ==== 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**. ==== Declarar el tipo explícitamente ==== 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 ====Declarar e inicializar==== * 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 === ¿Qué estilo debemos utilizar? === 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 === 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, 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. ^ Tipo ^ Uso ^ | Byte | Números de tamaño byte | | Short | Números enteros con 2 bytes| | Int | Números enteros | | Long | Números enteros grandes | | Float | Números decimales | | Double | Números decimales mayor precisión | | Boolean | Verdadero / falso | | Char | Un carácter | | String | Cadena de texto| |Array| Colección fija de elementos| ==== Númericos ==== Dentro de los datos numéricos podemos diferenciar entre: * Valores enteros: Byte, Short, Int y Long * Valores de coma flotante: Float y Double === Enteros === ^ Tipo ^ bits ^ Valor mínimo ^ Valor máximo ^ | ''Byte'' | 8 | -128 | 127 | | ''Short'' | 16 | -32.768 | 32.767 | | ''Int'' | 32 | -2.147.483.648 ó (-231) | 2.147.483.647 ó (231 - 1) | | ''Long'' | 64 | -9.223.372.036.854.775.808 ó (-263) | 9.223.372.036.854.775.807 ó (263 - 1) | 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.** ==== Números decimales ==== ^ Tipo ^ Tamaño (bits) ^ Bits significativos ^ Bits de exponente ^ Dígitos decimales ^ | ''Float'' | 32 | 24 | 8 | 6-7 | | ''Double'' | 64 | 53 | 11 | 15-16 | ''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. ==== Boolean ==== 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 ==== ''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: ^ Secuencia admitida ^ Descripción ^ | ''\t'' | Tabulación | | ''\b'' | Retroceso (Backspace) | | ''\n'' | Nueva línea (LF) | | ''\r'' | Retorno de carro (CR) | | ''\''' | Comilla simple | | ''\"'' | Comilla doble | | ''\\'' | Barra invertida (Backslash) | | ''\$'' | Signo de dólar | === Operaciones con Char=== 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 [[https://kotlinlang.org/api/core/kotlin-stdlib/kotlin/-char/|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' ==== String ==== * 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. === Interpolación === 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") === Concatenación === 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 === Longitud de una cadena === Podemos obtener la longitud (cantidad de caracteres) utilizando la propiedad''length'': val nombre = "Kotlin" println(nombre.length) //muestra 6 === Acceder a caracteres === 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''. ===Funciones de String=== 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] ==== Array ==== 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. ===Crear Arrays=== * Función ''arrayOf()'' * Función ''arrayOfNulls()'' * Constructor ''Array<>()'' * Arrays de tipos primitivos === arrayOf() === 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("Ana", "Luis", "Marta") //array String === arrayOfNulls() === Crea un array de un tamaño concreto rellenado con valores ''null': val nullArray = arrayOfNulls(3) === Constructor Array() === Permite crear un array de un tipo concreto, asignando un valor inicial a sus //celdas//: val nombres = Array(5) {""} // Array de tamaño 5 con el valor "" val numeros = Array(10) {0} // Array con el valor 0 === Arrays de tipos primitivos === 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 === Acceder y modificar elementos === 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 === Operaciones sobre array === * 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: ^ Función / Propiedad ^ Finalidad ^ | ''shuffle()'' | Mezcla aleatoriamente los elementos del array. | | ''sort()'' | Ordena los elementos del array de menor a mayor o según su orden natural. | | ''fill(element, fromIndex, toIndex)'' | Rellena el array, o un rango del mismo, con el valor indicado. | | ''indices'' | Devuelve el rango de índices válidos del array. | | ''lastIndex'' | Devuelve el último índice válido del array. | | ''first()'' | Devuelve el primer elemento del array. | | ''last()'' | Devuelve el último elemento del array. | | ''isEmpty()'' | Devuelve ''true'' si el array está vacío. | | ''isNotEmpty()'' | Devuelve ''true'' si el array contiene algún elemento. | ===Arrays anidados=== Conocido en otros lenguajes como matrices, son arrays de arrays, o arrays de 2 dimensiones: val matriz = Array(2) { Array(2) { 0 } } // [[0, 0], [0, 0]] matriz[0][1] = 25 Se modifican con 2 indices, y se recorren con dos bucles. === Ejercicio 4 === Crea un array con cinco nombres. Muestra: *El primer nombre. *El último nombre. *El número de elementos. ===== Conversiónes de tipos ===== * 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() === Ejercicio 5 === 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: val a = 10 val b = 3 println(a + b) println(a - b) println(a * b) println(a / b) println(a % b) === División entera === 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) === Módulo === 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") } ==== Operadores de asignación ==== 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 ==== Operadores de Incremento y decremento ==== Podemos incrementar y decrementar una variable: var contador = 0 contador++ contador-- Son especialmente habituales en bucles. ==== Operadores de comparación ==== 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: ^ Operador ^ Significado ^ | == | Igual | | != | Distinto | | > | Mayor | | < | Menor | | >= | Mayor o igual | | <= | Menor o igual | Ejemplo: val edad = 20 println(edad >= 18) Resultado: true ==== Operadores lógicos ==== Se utilizan para realizar operaciones entre valores de tipo ''Boolean'' y dan como resultado un valor de tipo ''Boolean''. ^ Operador ^ Significado ^ | && | AND | | || | OR | | ! | NOT | === AND === ''&&'' devuelve ''true'' cuando ambas condiciones son verdaderas. val edad = 20 val tieneCarnet = true if (edad >= 18 && tieneCarnet) { println("Puede conducir") } === OR === ''||'' devuelve ''true'' cuando al menos una condición es verdadera. val esSabado = true val esDomingo = false if (esSabado || esDomingo) { println("Es fin de semana") } === NOT === ''!'' invierte el valor lógico. val activo = true println(!activo) //false === Ejercicio 6 === 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 ''-''. ===== Sentencias de Control de Flujo ===== 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** ==== Sentencia if-else ==== 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" === Ejercicio 7 === Crea un programa que indique si un número es positivo, negativo o cero, y después si es par o impar. === Ejercicio 8 === Crea un programa que reciba una edad y muestre: *Menor de edad. *Adulto. *Mayor de 65 años. === Ejercicio 9 === Crea un programa que reciba una nota de 0 a 10 y muestre: *Suspenso: < 5 *Aprobado: 5–6 *Notable: 7–8 *Sobresaliente: 9–10 ==== Sentencia when ==== * ''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) === when sin argumento === 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") } === ¿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. === Ejercicio 10 === Crea un programa que reciba un número del 1 al 12 y muestre el mes correspondiente. === Ejercicio 11 === Crea un programa que reciba una opción de menú: 1 → Alta 2 → Baja 3 → Modificar 4 → Consultar Utiliza ''when''. ==== Bucle while ==== 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 ==== Bucle do-while ==== 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 === Ejercicio 12 === Crea un programa que muestre los números del 10 al 1 utilizando ''while''. ==== Sentencias break y continue==== * ''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) ``` } === Ejercicio 13 === Crea un programa que recorra los números del 1 al 20 y muestre solamente los números pares. Hazlo utilizando ''continue''. ==== Bucle for ==== 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 ==== Rangos ==== 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 } === Recorrer un String === Los caracteres de una cadena también pueden recorrerse: val nombre = "Kotlin" for (letra in nombre) { print("$letra ") // K o t l i n } === Recorrer un array mediante sus índices === Podemos utilizar la propiedad ''indices'': val nombres = arrayOf("Ana", "Luis", "Marta") for (i in nombres.indices) { println(nombres[i]) } === Ejercicio 14 === Crea un array de cinco números y utiliza un ''for'' para calcular la suma de todos ellos. === Ejercicio 15 === 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. ===== Funciones ===== Una función es un bloque de código que realiza una tarea concreta. Las funciones se declaran mediante la palabra clave ''fun''. ==== Sintaxis ==== fun saludar() { println("Hola") } // Ejecutamos mediante fun main() { saludar() } ==== Parámetros ==== * 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") ==== Valor de retorno ==== 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") } ==== Funciones de una sola expresión ==== 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 =====Ejercicios de repaso ===== === Ejercicio 16 === Crea una función: saludar() que muestre un saludo. === Ejercicio 17 === Crea una función: saludar(nombre) que reciba un nombre y muestre: Hola, nombre === Ejercicio 18 === Crea una función ''sumar()'' que reciba dos números enteros y devuelva su suma. === Ejercicio 19 === Crea las siguientes funciones: restar() multiplicar() dividir() 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. === 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: esPar(numero) esPositivo(numero) calcularMedia(notas) obtenerMaximo(notas) obtenerMinimo(notas) Utiliza estas funciones desde ''main()''. ===== Prácticas ===== ==== Práctica 1 ==== 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. ==== Práctica 2 ==== 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 ==== Práctica 3 ==== 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. ==== Práctica 4 ==== 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. ===== Resumen de sintaxis ===== === Variables === val nombre = "Ana" var edad = 20 === Tipos explícitos === val edad: Int = 20 val nombre: String = "Ana" val altura: Double = 1.80 val activo: Boolean = true val letra: Char = 'A' === Salida === print("Hola") println("Hola") === Interpolación === println("Hola $nombre") println("El resultado es ${a + b}") === Conversión === numero.toInt() numero.toDouble() numero.toLong() numero.toFloat() === Condicional === if (condicion) { // ... } else { // ... } === when === when (valor) { 1 -> println("Uno") 2 -> println("Dos") else -> println("Otro") } === while === while (condicion) { // ... } === do-while === do { // ... } while (condicion) === for === for (elemento in elementos) { // ... } === Rangos === 1..10 10 downTo 1 1..10 step 2 1..<10 === Arrays === val numeros = arrayOf(10, 20, 30) println(numeros[0]) numeros[0] = 100 println(numeros.size) === Función === fun saludar() { println("Hola") } === Función con parámetros === fun saludar(nombre: String) { println("Hola $nombre") } === Función con retorno === fun sumar(a: Int, b: Int): Int { return a + b } === Función de expresión única === fun sumar(a: Int, b: Int) = a + b ---- ===== Crear un Proyecto en Android Studio ===== VideoTutorial para crear y configurar un proyecto de Android Studio para Kotlin {{ youtube>c7tEXxIdgjQ?medium }} > Crear un proyecto para Kotlin en AndroidStudio ---- (c) {{date> %Y}} Fernando Valdeón