Formación corporativa en Kotlin

Kotlin es un lenguaje de programación moderno que ha ganado popularidad gracias a su concisión y seguridad. En esta guía, exploraremos en detalle la sintaxis de Kotlin, proporcionando una base sólida para desarrollar aplicaciones eficientes y robustas.

Declaración de variables

En Kotlin, las variables se declaran utilizando val o var:

• val: declara una variable inmutable (constante).
• var: declara una variable mutable.

Ejemplo:

val nombre: String = "Ana"
var edad: Int = 30

Si el tipo puede ser inferido, se puede omitir:

val nombre = "Ana"
var edad = 30

Tipos de datos básicos

Kotlin proporciona varios tipos de datos integrados:

• Números enteros: Byte, Short, Int, Long
• Números de coma flotante: Float, Double
• Caracteres: Char
• Cadenas de texto: String
• Booleanos: Boolean

Ejemplo:

val numeroEntero: Int = 100
val numeroDecimal: Double = 123.45
val caracter: Char = 'A'
val cadena: String = "Hola, Kotlin"
val booleano: Boolean = true

Cadenas de texto

Las cadenas se pueden declarar con comillas dobles. Para cadenas multilínea, se utilizan comillas triples (""").

Interpolación de cadenas:

val nombre = "Ana"
val saludo = "Hola, $nombre"

Cadenas multilínea:

val texto = """
    |Primera línea
    |Segunda línea
""".trimMargin()

La programación orientada a objetos (POO) es un paradigma esencial en muchos lenguajes de programación modernos, y Kotlin no es la excepción. Kotlin ofrece una implementación clara y concisa de los principios de POO, integrando características que facilitan la escritura de código limpio y mantenible. A continuación, exploraremos los conceptos fundamentales de la POO en Kotlin y cómo aplicarlos en tus proyectos.

Clases y objetos en Kotlin

En Kotlin, las clases se definen utilizando la palabra clave class. Una clase es un molde a partir del cual se crean objetos, que son instancias concretas de esa clase.

Definición de una clase

class Persona(val nombre: String, var edad: Int)

En este ejemplo, Persona es una clase con dos propiedades: nombre y edad. La palabra clave val indica que nombre es una propiedad de solo lectura, mientras que var indica que edad es mutable.

Creación de objetos

Para crear una instancia de la clase Persona:

val persona = Persona("Ana", 30)
println("Nombre: ${persona.nombre}, Edad: ${persona.edad}")

Este código creará un objeto persona con el nombre "Ana" y edad 30.

Constructores en Kotlin

Kotlin proporciona un constructor primario y constructores secundarios para inicializar objetos.

Constructor primario

El constructor primario se define junto al nombre de la clase:

class Coche(val marca: String, val modelo: String)

Constructores secundarios

Si necesitas más de un constructor, puedes definir constructores secundarios utilizando constructor:

class Coche {
    val marca: String
    val modelo: String

    constructor(marca: String, modelo: String) {
        this.marca = marca
        this.modelo = modelo
    }

    constructor(marca: String) {
        this.marca = marca
        this.modelo = "Modelo desconocido"
    }
}

Herencia en Kotlin

La herencia permite crear nuevas clases a partir de clases existentes. En Kotlin, todas las clases son finales por defecto, es decir, no se pueden heredar a menos que se declaren como open.

Declaración de una clase base

open class Animal(val nombre: String) {
    fun comer() {
        println("$nombre está comiendo")
    }
}

Subclase que hereda de una clase base

class Perro(nombre: String) : Animal(nombre) {
    fun ladrar() {
        println("$nombre está ladrando")
    }
}

Aquí, Perro es una subclase de Animal y hereda sus propiedades y métodos.

Las estructuras de datos son componentes fundamentales en la programación, permitiendo organizar y manipular datos de manera eficiente. Kotlin, como lenguaje moderno y versátil, proporciona una amplia variedad de estructuras de datos que facilitan el desarrollo de aplicaciones robustas. En este artículo, exploraremos las principales estructuras de datos en Kotlin y cómo utilizarlas correctamente.

Listas en Kotlin

Las listas son colecciones ordenadas que permiten almacenar elementos en una secuencia. Kotlin ofrece dos tipos principales de listas: listas inmutables y listas mutables.

Listas inmutables

Las listas inmutables no permiten modificar sus elementos después de la creación. Se crean utilizando la función listOf().

val numeros = listOf(1, 2, 3, 4, 5)

Características de las listas inmutables:

• Lectura segura: al ser inmutables, no hay riesgo de modificar accidentalmente los elementos.
• Uso compartido: se pueden compartir entre diferentes partes del programa sin preocuparse por modificaciones.

Operaciones con listas inmutables

Aunque no se pueden modificar, es posible realizar varias operaciones que devuelven nuevas listas:

• Añadir elementos:

  val nuevosNumeros = numeros + 6

• Eliminar elementos:

  val menosNumeros = numeros - 1

Listas mutables

Las listas mutables permiten modificar su contenido después de la creación. Se crean utilizando la función mutableListOf().

val frutas = mutableListOf("Manzana", "Banana", "Cereza")
frutas.add("Durazno")

Operaciones habituales:

• Agregar elementos:

  frutas.add("Mango")

• Eliminar elementos:

  frutas.remove("Banana")

• Modificar elementos:

  frutas[0] = "Fresa"

Conjuntos en Kotlin

Los conjuntos son colecciones que no permiten elementos duplicados. Son útiles cuando se necesita garantizar la unicidad de los elementos.

Conjuntos inmutables

Se crean utilizando setOf().

val colores = setOf("Rojo", "Verde", "Azul")

Características:

• Sin duplicados: añadir un elemento ya existente no cambia el conjunto.
• Orden no garantizado: el orden de los elementos puede no ser el mismo al iterar.

Conjuntos mutables

Se crean con mutableSetOf().

val numerosSet = mutableSetOf(1, 2, 3)
numerosSet.add(4)

Operaciones comunes:

• Agregar elementos:

  numerosSet.add(2) // No se agregará ya que 2 ya existe

• Eliminar elementos:

  numerosSet.remove(3)

Mapas en Kotlin

Los mapas almacenan pares clave-valor, permitiendo asociar valores a claves únicas.

Mapas inmutables

Se crean con mapOf().

val capitales = mapOf("España" to "Madrid", "Francia" to "París")

Características:

• Claves únicas: no puede haber claves duplicadas.
• Valores asociados: cada clave tiene un valor correspondiente.

Mapas mutables

Se crean con mutableMapOf().

val edades = mutableMapOf("Juan" to 30, "María" to 25)
edades["Pedro"] = 40

Operaciones habituales:

• Agregar o modificar entradas:

  edades["María"] = 26 // Modifica el valor existente

• Eliminar entradas:

  edades.remove("Juan")

• Acceder a valores:

  val edadDeMaría = edades["María"]

La programación funcional es un paradigma que trata el cálculo como la evaluación de funciones matemáticas y evita el cambio de estado y los datos mutables. Kotlin, como lenguaje moderno y versátil, ofrece un sólido soporte para este estilo de programación, permitiendo combinarlo con la programación orientada a objetos de manera fluida.

A continuación, exploraremos cómo Kotlin implementa los conceptos fundamentales de la programación funcional y cómo puedes aprovecharlos para escribir código más conciso, legible y fácil de mantener.

Funciones de orden superior

En Kotlin, las funciones son ciudadanos de primera clase. Esto significa que puedes asignarlas a variables, pasarlas como parámetros y retornarlas desde otras funciones. Las funciones que toman otras funciones como parámetros o las devuelven se denominan funciones de orden superior.

Ejemplo:

fun <T> filtrar(lista: List<T>, criterio: (T) -> Boolean): List<T> {
    val resultado = mutableListOf<T>()
    for (elemento in lista) {
        if (criterio(elemento)) {
            resultado.add(elemento)
        }
    }
    return resultado
}

// Uso de la función
val numeros = listOf(1, 2, 3, 4, 5)
val pares = filtrar(numeros) { it % 2 == 0 }
println(pares) // Imprime: [2, 4]

En este ejemplo, filtrar es una función genérica que acepta una lista y un criterio de filtrado. El criterio es una función que recibe un elemento y devuelve un booleano.

Lambdas y funciones anónimas

Las expresiones lambda son funciones anónimas que se pueden utilizar cuando se necesita una función como argumento. En Kotlin, las lambdas se representan con la sintaxis { parámetros -> cuerpo }.

Ejemplo:

val suma = { a: Int, b: Int -> a + b }
println(suma(3, 4)) // Imprime: 7

Si el tipo puede inferirse, es posible omitirlo:

val numeros = listOf(1, 2, 3, 4, 5)
val cuadrados = numeros.map { it * it }
println(cuadrados) // Imprime: [1, 4, 9, 16, 25]

Funciones puras y transparencia referencial

Una función pura es aquella que siempre devuelve el mismo resultado para los mismos argumentos y no produce efectos secundarios. Esto significa que no modifica variables externas ni interactúa con el mundo exterior.

Ejemplo de función pura:

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

Ejemplo de función con efectos secundarios:

var contador = 0

fun incrementarContador() {
    contador += 1
}

Las funciones puras favorecen la transparencia referencial, lo que facilita la razón acerca del código y su prueba unitaria.

Coroutines y asincronía en Kotlin

La programación asíncrona representa uno de los paradigmas más importantes en el desarrollo moderno de aplicaciones. En lugar de ejecutar operaciones de forma secuencial y bloqueante, permite que el programa continúe ejecutando otras tareas mientras espera que se completen operaciones lentas como llamadas a APIs, acceso a bases de datos o lectura de archivos.

Kotlin introduce las coroutines como su solución nativa para la programación asíncrona, ofreciendo una alternativa elegante y eficiente a los callbacks tradicionales y los threads. Las coroutines permiten escribir código asíncrono que se lee de forma secuencial, eliminando la complejidad típica asociada con la gestión manual de hilos.

¿Qué son las coroutines?

Las coroutines son funciones que pueden suspender su ejecución en puntos específicos y reanudarla posteriormente sin bloquear el hilo en el que se ejecutan. Esta capacidad de suspensión es fundamental para crear aplicaciones eficientes que no desperdicien recursos del sistema.

A diferencia de los threads tradicionales, que son costosos de crear y mantener, las coroutines son extremadamente ligeras. Es posible ejecutar miles de coroutines simultáneamente sin impacto significativo en el rendimiento, algo impensable con threads convencionales.

import kotlinx.coroutines.*

fun main() {
    runBlocking {
        launch {
            delay(1000L) // Suspende por 1 segundo sin bloquear
            println("Mundo!")
        }
        println("Hola ")
    }
}

En este ejemplo, delay() es una función suspendible que pausa la ejecución de la coroutine sin bloquear el hilo principal, permitiendo que otras operaciones continúen.

Funciones suspendibles

Las suspend functions son el corazón de las coroutines en Kotlin. Estas funciones pueden pausar su ejecución y ceder el control a otras coroutines, optimizando el uso de recursos del sistema.

suspend fun obtenerDatos(): String {
    delay(2000L) // Simula una operación lenta
    return "Datos obtenidos"
}

suspend fun procesarDatos(datos: String): String {
    delay(1000L) // Simula procesamiento
    return "Procesado: $datos"
}

Las funciones suspendibles solo pueden ser llamadas desde otras funciones suspendibles o desde dentro de una coroutine. Esta restricción garantiza que el mecanismo de suspensión funcione correctamente.