Introducción

Kotlin es un lenguaje de programación moderno que se ejecuta en la JVM (Java Virtual Machine). Es completamente interoperable con Java y ofrece una sintaxis más concisa, seguridad de nulos y muchas características modernas.

¿Por Qué Kotlin?

Ventajas sobre Java:

• Código más conciso (menos código repetitivo)
• Seguridad de nulos integrada en el sistema de tipos
• Funciones de extensión
• Clases de datos
• Corrutinas para programación asíncrona
• Conversiones inteligentes
• Parámetros por defecto y con nombre

Configurando Kotlin

IntelliJ IDEA:

// Instala IntelliJ IDEA (Community o Ultimate)
// El soporte de Kotlin viene incluido
// File -> New -> Project -> Kotlin

Primer Programa en Kotlin:

fun main() {
    println("¡Hola, Kotlin!")
}

Sintaxis Básica

Variables:

// Inmutable (solo lectura) - preferida
val nombre = "Alicia"
val edad = 25

// Mutable (puede cambiar)
var puntaje = 100
puntaje = 150  // OK

// Declaración de tipo explícita
val saludo: String = "Hola"
val conteo: Int = 42

Inferencia de Tipos: Kotlin infiere tipos automáticamente:

val numero = 42              // Int
val pi = 3.14159            // Double
val estaActivo = true       // Boolean
val mensaje = "Hola"        // String

Tipos de Datos

Tipos Primitivos:

val byte: Byte = 127
val short: Short = 32767
val int: Int = 2147483647
val long: Long = 9223372036854775807L

val float: Float = 3.14f
val double: Double = 3.14159

val char: Char = 'A'
val boolean: Boolean = true

Plantillas de String:

val nombre = "Alicia"
val edad = 25

// Interpolación de strings
println("Nombre: $nombre")
println("Edad en 5 años: ${edad + 5}")

// Strings multi-línea
val poema = """
    |Las rosas son rojas
    |Las violetas azules
    |Kotlin es genial
    |Y tú también
""".trimMargin()

Operaciones Básicas

Aritméticas:

val a = 10
val b = 3

println(a + b)  // 13
println(a - b)  // 7
println(a * b)  // 30
println(a / b)  // 3
println(a % b)  // 1

Comparación:

val x = 5
val y = 10

println(x == y)   // false
println(x != y)   // true
println(x < y)    // true
println(x > y)    // false
println(x <= y)   // true
println(x >= y)   // false

Operadores Lógicos:

val esAdulto = true
val tieneLicencia = false

println(esAdulto && tieneLicencia)  // false (AND)
println(esAdulto || tieneLicencia)  // true (OR)
println(!esAdulto)                  // false (NOT)

Control de Flujo

Expresión If:

val edad = 18
val estado = if (edad >= 18) "Adulto" else "Menor"

// If multi-línea
val resultado = if (puntaje >= 90) {
    println("¡Excelente!")
    "A"
} else if (puntaje >= 80) {
    "B"
} else {
    "C"
}

Expresión When (Switch):

val diaDeLaSemana = 3

val nombreDia = when (diaDeLaSemana) {
    1 -> "Lunes"
    2 -> "Martes"
    3 -> "Miércoles"
    4 -> "Jueves"
    5 -> "Viernes"
    6, 7 -> "Fin de semana"
    else -> "Día inválido"
}

// Con rangos
when (edad) {
    in 0..12 -> println("Niño")
    in 13..17 -> println("Adolescente")
    in 18..64 -> println("Adulto")
    else -> println("Adulto mayor")
}

Rangos

// Rango de 1 a 10 (inclusivo)
for (i in 1..10) {
    println(i)
}

// Rango excluyendo último valor
for (i in 1 until 10) {
    println(i)  // 1 a 9
}

// Rango inverso
for (i in 10 downTo 1) {
    println(i)
}

// Con pasos
for (i in 0..100 step 10) {
    println(i)  // 0, 10, 20, ..., 100
}

// Verificar si un valor está en el rango
val puntaje = 85
if (puntaje in 80..90) {
    println("¡Buen puntaje!")
}

Buenas Prácticas

• Prefiere val sobre var para inmutabilidad
• Usa inferencia de tipos cuando el tipo es obvio
• Usa plantillas de string en lugar de concatenación
• Usa when para lógica condicional compleja
• Aprovecha los rangos para iteraciones numéricas

Patrones Comunes

Operador Elvis:

val nombre: String? = null
val nombreMostrado = nombre ?: "Desconocido"  // "Desconocido"

Llamada Segura:

val longitud = nombre?.length  // null si nombre es null

Desestructuración:

val (x, y) = Pair(10, 20)
println("x: $x, y: $y")

Conclusión

Kotlin ofrece una sintaxis moderna y concisa mientras mantiene interoperabilidad completa con Java. Comprender estos conceptos básicos te prepara para características más avanzadas de Kotlin.

En el próximo capítulo, exploraremos funciones y funciones de extensión en detalle.