Recordad que la forma más sencilla de comprobar todos estos códigos es en la web de Kotlin PlayGround.
Como pasa en Java, en Kotlin los paquetes se colocan en la parte superior del archivo:
package com.example import com.example.* // ...
Hay dos tipos de variables, val
y var
.
La variable val
una vez asignada solo se puede leer, es decir, una vez se le asigna su valor no puede cambiar. val
en Kotlin sería como añadir a final
a una variable en Java.
var
por otro lado si podría cambiar su valor.
fun main() { //sampleStart val numeroFinal = 2 // Deduce que el tipo es 'Int' numeroFinal = 3 // Provocaría un error ya que no se puede volver a asignar var numeroVariable = 2 // Deduce que el tipo es 'Int' numeroVariable = 4 // No generaría un error numeroVariable = "hola" // Provocaría un error ya que es de tipo 'Int' val numeroTardio: Int // Puedes asignar el valor más tarde numeroTardio = 6 //sampleEnd }
Como has visto en el bloque de código anterior, no es necesario indicarle el tipo, ya que Kotlin puede detectarlo automáticamente una vez que le asignas un valor.
También es posible indicar el tipo si así lo deseas:
val numero: Int = 1 // Le indicas explícitamente que es de tipo 'Int'
Las funciones en Kotlin se definen con fun
, por ejemplo vamos a hacer una función que sume dos números y los muestre por pantalla:
//sampleStart fun mostrarSuma(a: Int, b: Int) { println("La suma de $a y $b es ${a + b}") } //sampleEnd fun main() { mostrarSuma(1, 4) }
Con la siguiente función vamos a ver como devolver un valor, en este caso un entero, añadiendo el tipo al final, en este caso Int
:
//sampleStart fun suma(a: Int, b: Int): Int { return a + b } //sampleEnd fun main() { println("La suma sería de 1 y 4 es ${suma(1, 4)}") }
Otra forma de definir esa función es la siguiente:
//sampleStart fun suma(a: Int, b: Int) = a + b // Deduce el tipo 'Int' //sampleEnd fun main() { println("La suma sería de 1 y 4 es ${suma(1, 4)}") }
Esta forma es muy útil con funciones simples ya que facilita su lectura y puedes ahorrar un montón del líneas.
Te habrás fijado que en una de las funciones anteriores ya hemos una plantilla, y que gracias a ellas con Kotlin no vamos a tener que utilizar el signo +
para encadenar textos que tanto se ha usado en Java.
Su uso es muy simple, solo tienes que usar el símbolo $
y el nombre de la variable:
fun main() { //sampleStart var numero = 1 val texto = "El número es $numero" println(texto) // "El número es 1" //sampleEnd }
No tiene demasiado misterio ya que en Kotlin su sintaxis es prácticamente idéntica a Java:
//sampleStart fun mayorNumero(a: Int, b: Int): Int { if (a > b) { return a } else { return b } } //sampleEnd fun main() { println("El mayor número de 2 y 3 es ${mayorNumero(2, 3)}") }
Una forma de ahorrar código sería:
//sampleStart fun mayorNumero(a: Int, b: Int) = if (a > b) a else b //sampleEnd fun main() { println("El mayor número de 2 y 3 es ${mayorNumero(2, 3)}") }
La sintaxis de Kotlin para los bucles difiere de la de Java un poco.
Los intervalos de Kotlin serían los clásicos bucles for
con i
en Java.
fun main() { //sampleStart for (i in 1..3) { print("$i ") // "1 2 3" } //sampleEnd }
fun main() { //sampleStart for (i in 10 downTo 0 step 2) { print("$i ") // "10 8 6 4 2 0" } //sampleEnd }
Mientras tanto, con los bucles for
en Kotlin nos estaríamos refiriendo a los foreach
de Java.
fun main() { //sampleStart val frutas = listOf("platano", "manzana", "pera", "kiwi") for (fruta in frutas) { println(fruta) } //sampleEnd }
Si quisiésemos utilizar una plantilla de texto con un índice:
fun main() { //sampleStart val frutas = listOf("platano", "manzana", "pera", "kiwi") for (index in frutas.indices) { println("La fruta en la posición $index es ${frutas[index]}") } //sampleEnd }
Esta expresión en Kotlin sería el equivalente a Switch en Java:
//sampleStart fun describir(obj: Any): String = when (obj) { 1 -> "Uno" "hola" -> "Saludos" is Int -> "Número entero" !is String -> "No es un texto" else -> "Desconocido" } //sampleEnd fun main() { println(describir(1)) // "Uno" println(describir("hola")) // "Saludos" println(describir(3)) // "Número entero" println(describir(true)) // "No es un texto" }
Con Any
lo que le estamos indicando es que objeto puede ser de cualquier tipo.
import kotlin.random.Random fun main() { //sampleStart var numero = 0 while (numero!=2) { numero = Random.nextInt(0,6) print("$numero ") } //sampleEnd }
Iterar a través de una colección:
fun main() { //sampleStart val frutas = listOf("platano", "manzana", "pera", "kiwi") for (fruta in frutas) { println(fruta) } //sampleEnd }
Para comprobar si una colección contiene un objeto:
fun main() { val frutas = listOf("platano", "manzana", "pera", "kiwi") for (fruta in frutas) { println(fruta) } //sampleStart when { "naranja" in frutas -> println("zumo") "manzana" in frutas -> println("me gusta la manzana") } //sampleEnd }
Utilizando expresiones lambda para filtrar y mapear una colección
fun main() { val frutas = listOf("platano", "manzana", "pera", "kiwi") //sampleStart frutas.filter { it.startsWith("p") } .sortedBy { it } .map { it.toUpperCase() } .forEach { println(it) } //sampleEnd }
En el siguiente ejemplo vas a ver como Kotlin nos ahorra un montón de código respecto a Java, sobretodo al crear la clase, ya que no necesitamos indicarle los getters and setters, ni colocar todos los valores en el constructor con la palabra this
.
//sampleStart class Rectangulo(val ancho: Int, val largo: Int) { fun mostrar() = print("La base es de $ancho cm y la altura es de $largo cm") } //sampleEnd fun main() { val rectangulo = Rectangulo(5, 2) // Instanciamos 'Rectangulo' val ancho = rectangulo.ancho // Acceso a la propiedad 'ancho' val largo = rectangulo.largo // Acceso a la propiedad 'largo' val area = largo * ancho println("El area es $area cm") // "El area es 10 cm" rectangulo.mostrar() // Se ejecuta la función 'mostrar' }
Si por algún motivo quieres que algo sea nulo, en Kotlin puedes indicarlo mediante el símbolo ?
.
Por ejemplo, si la siguiente función le pasásemos un texto que no sea número entero, devolvería null
.
fun main() { //sampleStart val numeroString = "10" // Tipo string val numeroInt = numeroString.toIntOrNull() // Si es un número entero será Int, sino será null println(numeroInt ?: "No es un número") // "10" val texto = "Hola" val numero = texto.toIntOrNull() // Será 'null' en este caso println(numero ?: "No es un número") // "No es un número" //sampleEnd }
El operador is
es el encargado de comprobar si una expresión es un tipo o una instancia. Si una variable local es inmutable o se le ha indicado el tipo específicamente, no hay necesidad de hacer una conversión (casting) explícita.
//sampleStart fun obtenerTipo(valor: Any): String { return when (valor) { is String -> "String" is Int -> "Int" is Boolean -> "Boolean" else -> "Tipo desconocido" } } //sampleEnd fun main() { println(obtenerTipo("Hola")) // "String" println(obtenerTipo(10)) // "Int" println(obtenerTipo(true)) // "Boolean" println(obtenerTipo(20f)) // "Tipo Desconocido" ya que no hemos definido float }
En esta lección aprenderás a declarar variables y los tipos básicos.
La mejor forma de aprender algo en esta vida es a base de practicar. Espero…
La principal forma de iniciar una corrutina en Kotlin es con el coroutine builder launch…
Las coroutines en Kotlin vienen a tratar de solucionar todos los problemas y dificultades que…
Con este esquema te puedes guiar a la hora de elegir el modismo o función…
El último que queda por ver es with qué en inglés significa "con". Por lo…