Aplicaciones moviles con Kotlin (II)

Declaración de clases y constructores

En Kotlin, las clases se declaran de manera concisa y flexible. Una clase básica puede declararse con la palabra clave class:

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

• Constructores primarios: Definidos directamente junto al nombre de la clase, como en el ejemplo anterior.
• Constructores secundarios: Se usan para inicializar una clase de manera diferente y se declaran dentro del cuerpo de la clase utilizando la palabra clave constructor.

Además, Kotlin simplifica la inicialización de propiedades mediante constructores primarios.

Variables y propiedades

Kotlin tiene dos tipos principales de variables:

• val (inmutable): Una vez asignado, su valor no puede cambiar (similar a final en Java).
• var (mutable): Su valor puede modificarse después de ser asignado. Ejemplo:

val constante = 10 // Inmutable
var variable = 5   // Mutable
variable = 15

Las propiedades son variables asociadas a clases que pueden tener métodos de acceso personalizados (get y set).

Nulabilidad

Kotlin tiene un enfoque seguro para manejar valores nulos, evitando problemas comunes como el NullPointerException (NPE).

• Por defecto, las variables no pueden ser nulas:

var nombre: String = "Kotlin"
// nombre = null // Error de compilación

• Para permitir nulos, se usa el operador ?:

var apellido: String? = null

• Se puede acceder de manera segura con el operador safe call (?.) o manejar con el operador Elvis (?:):

val longitud = apellido?.length ?: 0 // Si es null, devuelve 0

Casting de objetos

Kotlin simplifica el casting utilizando el operador as para convertir tipos:

val obj: Any = "Hola Kotlin"
val texto = obj as String // Casting explícito

Además, con smart casting, el compilador realiza automáticamente el casting tras una verificación:

if (obj is String) {
    println(obj.length) // No es necesario hacer un casting manual
}

Inmutabilidad

La inmutabilidad es clave en Kotlin para construir aplicaciones seguras y predecibles. Los objetos inmutables no pueden cambiar su estado después de ser creados:

• Clases inmutables: Se crean utilizando val para propiedades.
• Colecciones inmutables: Kotlin proporciona colecciones como listOf o mapOf que no pueden modificarse:

val lista = listOf(1, 2, 3) // Lista inmutable
// lista.add(4) // Error: no se puede modificar

Iteradores

Kotlin facilita la iteración sobre colecciones con bucles como for:

val numeros = listOf(1, 2, 3, 4)
for (num in numeros) {
    println(num)
}

También puedes usar funciones como forEach para iterar:

numeros.forEach { println(it) }

Colecciones

Kotlin ofrece colecciones mutables y inmutables:

• Listas: listOf (inmutables) y mutableListOf (mutables).
• Mapas: mapOf (inmutables) y mutableMapOf (mutables).
• Conjuntos: setOf (inmutables) y mutableSetOf (mutables).

Ejemplo:

val listaMutable = mutableListOf(1, 2, 3)
listaMutable.add(4) // Se puede modificar

Funciones como map, filter, y reduce permiten trabajar con colecciones de manera funcional.

Excepciones

El manejo de excepciones en Kotlin es similar a Java pero con una sintaxis más concisa:

• Para capturar excepciones, se usa try-catch:

try {
    val resultado = 10 / 0
} catch (e: ArithmeticException) {
    println("Error: ${e.message}")
} finally {
    println("Bloque final ejecutado")
}

• A diferencia de Java, Kotlin no obliga a declarar excepciones con throws.

Lambdas

Una lambda es una función anónima que puede ser asignada a una variable o pasada como argumento. Su sintaxis básica es:

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

Las lambdas son muy útiles para trabajar con colecciones:

val numeros = listOf(1, 2, 3)
val pares = numeros.filter { it % 2 == 0 }
println(pares) // Imprime [2]

Binding de Vistas

El View Binding en Kotlin es una forma segura y eficiente de interactuar con vistas de una interfaz gráfica. Genera clases automáticamente para acceder a las vistas, eliminando la necesidad de usar findViewById:

1. En el archivo build.gradle:

   viewBinding {
       enabled = true
   }
   

2. Usarlo en la actividad:

   val binding = ActivityMainBinding.inflate(layoutInflater)
   setContentView(binding.root)
   binding.textView.text = "Hola View Binding"
   

Listeners

Los listeners permiten capturar eventos de usuario, como clics o pulsaciones de botones. Kotlin simplifica su implementación con lambdas:

button.setOnClickListener {
    println("Botón presionado")
}

También puedes usar listeners más complejos, como OnLongClickListener:

button.setOnLongClickListener {
    println("Clic largo detectado")
    true // Retorna true para indicar que el evento ha sido manejado
}