1. Introducción
El PDF del documento está AQUÍ.
El código de este documento está AQUÍ.
Este documento es un producto de la IA Claude de Anthropic. Es la adaptación a Kotlin del curso “Aprender el lenguaje Java 25 mediante ejemplos” (octubre de 2026), que a su vez es una adaptación del curso “Aprender C# 14 con .NET 10 (octubre de 2026), una reescritura del curso “Aprendizaje del lenguaje C#, versión 3.0, con el framework .NET 3.5” escrito por Serge Tahé en mayo de 2008. Conserva el esquema, los ejemplos y el hilo conductor de ese curso, y los reescribe en el Kotlin actual:
- El documento usa Kotlin 2.4 (versión 2.4.20, septiembre de 2026), con JDK 25, la última versión de soporte a largo plazo (LTS) de Java. Kotlin es un lenguaje para la máquina virtual de Java: produce el mismo código intermedio que Java y utiliza directamente todas sus bibliotecas. Los lectores del curso de Java encontrarán, por lo tanto, las mismas clases del JDK (archivos, redes, hilos, fechas, etc.) y los mismos frameworks (JUnit, Spring, Jackson, Hibernate, Spring Boot), usados desde otro lenguaje;
- donde los dos lenguajes difieren, este documento hace algo más que traducir. Kotlin ofrece soluciones propias a problemas que Java resuelve de otra manera: la seguridad frente a nulos integrada en el sistema de tipos, las propiedades, las clases de datos, las funciones de extensión, la sobrecarga de operadores, los tipos funcionales, los valores predeterminados de parámetros y los argumentos con nombre, y la expresión [when]. A la inversa, Kotlin no tiene excepciones verificadas ni miembros [static]. Estas diferencias se presentan en detalle, a menudo comparando el código Kotlin con el código Java;
- el capítulo sobre programación asíncrona adquiere otro carácter: mientras que Java utiliza las clases [CompletableFuture] y los hilos virtuales, Kotlin ofrece corrutinas, junto con las funciones [suspend], los constructores [launch] y [async] y la concurrencia estructurada. Es la respuesta de Kotlin a [async] / [await] de C# en el curso original;
- las bibliotecas son las que se usan actualmente en la JVM: [JUnit 6] y [kotlin.test] para las pruebas, [Spring Framework 7] para la inyección de dependencias, [Jackson 3] para JSON, [kotlinx.coroutines] para las corrutinas, el controlador [MySQL Connector/J] para JDBC, [Hibernate 7] para el mapeo objeto-relacional y [Spring Boot 4] para los servicios web; los proyectos se construyen con [Gradle], cuyos scripts están escritos, a su vez, en Kotlin.
Este documento no es un curso exhaustivo. Al igual que los materiales de los que deriva, está dirigido a lectores que ya conocen la programación y desean aprender los fundamentos de Kotlin. Se basa en ejemplos: más de doscientos programas (más de trescientos archivos Kotlin), la mayoría breves, con comentarios línea por línea.
1.1. Kotlin de 2011 a 2026
Kotlin fue presentado en julio de 2011 por la empresa JetBrains, editora de los IDE, entre ellos IntelliJ IDEA, que buscaba un lenguaje más conciso y seguro que Java para escribir sus propias herramientas, pero compatible con él: un programa Kotlin se compila a bytecode, lo ejecuta la máquina virtual de Java (la JVM) y puede invocar código Java, así como ser invocado por este. El nombre proviene de una isla del golfo de Finlandia, cercana a San Petersburgo, donde trabajaba el equipo que lo diseñó.
Hitos principales:
- 2016: Kotlin 1.0, la primera versión estable, con el compromiso de compatibilidad que la acompañaba;
- 2017: Google anunció el soporte oficial de Kotlin para desarrollar aplicaciones Android; en 2019, Android adoptó el enfoque “Kotlin first”: Kotlin es el lenguaje recomendado para las nuevas aplicaciones Android;
- 2018: Kotlin 1.3, que estabilizó las corrutinas, la respuesta de Kotlin a la programación asíncrona (capítulo 9);
- El lenguaje es desarrollado por JetBrains; la Kotlin Foundation, fundada en 2017 por JetBrains y Google, supervisa su evolución, y cada etapa se somete a propuestas públicas (los “KEEP”, Kotlin Evolution and Enhancement Process);
- 2024: Kotlin 2.0, con un nuevo compilador llamado K2, más rápido y mejor para seguir los tipos en el código (conversión inteligente de tipos);
- Kotlin también apunta a plataformas distintas de la JVM: JavaScript, WebAssembly y código nativo (Kotlin/Native, iOS). Este documento trata únicamente de Kotlin en la JVM;
- desde la versión 2.0, aproximadamente cada seis meses se publica una nueva versión del lenguaje (2.1.0, 2.2.0, 2.3.0, 2.4.0…); entre una y otra, una versión de herramientas (2.x.20) aporta mejoras a las herramientas y a la biblioteca estándar sin cambiar el lenguaje. Este documento usa la versión 2.4.20, publicada en septiembre de 2026. Las novedades suelen introducirse primero como experimentales; deben entonces habilitarse explícitamente (mediante una opción del compilador o la anotación [@OptIn]) antes de volverse estables en una versión posterior.
La siguiente tabla resume las principales novedades del lenguaje presentadas en este documento e indica el capítulo en que aparecen:
Versión | Año | Novedades principales | Capítulo |
Kotlin 1.0 | 2016 | seguridad frente a nulos, propiedades, clases de datos, funciones de extensión, lambdas, [when], sobrecarga de operadores | 3, 4, 7 |
Kotlin 1.1 | 2017 | alias de tipo [typealias], referencias enlazadas [object::function], corrutinas (experimentales) | 4, 7 |
Kotlin 1.3 | 2018 | Corrutinas estables, función [main] sin parámetros | 2, 3, 9 |
Kotlin 1.4 | 2020 | Interfaces funcionales [fun interface], conversiones SAM de interfaces Kotlin | 7 |
Kotlin 1.5 | 2021 | Tipos sin signo ([UInt]…) y clases [value class] estables, interfaces selladas | 3, 4 |
Kotlin 1.9 | 2023 | Operador [..<], [entries] propiedad de las enumeraciones, [data object] | 3, 12 |
Kotlin 2.0 | 2024 | Compilador K2: conversiones inteligentes de tipos más precisas | 4 |
Kotlin 2.2 | 2025 | Condiciones de guarda en [when] ([is Int if x > 0 ->]), interpolación con múltiples [$] | 3, 5 |
Kotlin 2.3 | 2025 | Soporte de Java 25 | 2 |
Kotlin 2.4 | 2026 | En la versión 2.4.20, el lanzador [kotlinr] reemplaza al [kotlin] comando | 2 |
En cuanto a bibliotecas y herramientas, las novedades incluyen: la herramienta de construcción [Gradle] y sus scripts Kotlin ([build.gradle.kts]), las colecciones de la biblioteca estándar de Kotlin y sus funciones de orden superior, las secuencias, las corrutinas y los flujos ([Flow]), así como los principales frameworks del ecosistema Java usados desde Kotlin: JUnit, Spring, Jackson, Hibernate y Spring Boot.
1.2. Contenido del documento
El documento incluye los siguientes capítulos:
- Capítulo 2: Configuración del entorno de desarrollo (JDK 25, IntelliJ IDEA, el compilador [kotlinc], Gradle);
- Capítulo 3: Fundamentos del lenguaje (tipos, seguridad frente a nulos, operadores, [if] y [when], bucles, excepciones, enumeraciones, parámetros de funciones);
- Capítulo 4: Clases, propiedades, herencia, clases selladas, sobrecarga de operadores, interfaces, genéricos, clases de datos, funciones de extensión;
- Capítulo 5: Clases de Kotlin de uso frecuente: cadenas, arreglos, colecciones, secuencias, archivos de texto y binarios, JSON con Jackson, expresiones regulares;
- Capítulo 6: Arquitecturas en capas, pruebas unitarias con JUnit 6 e inyección de dependencias con Spring;
- Capítulo 7: Tipos funcionales, expresiones lambda y eventos;
- Capítulo 8: Hilos de ejecución, sincronización e hilos virtuales;
- Capítulo 9: Programación asíncrona con corrutinas;
- Capítulo 10: Acceso a bases de datos con JDBC;
- Capítulo 11: Hibernate;
- Capítulo 12: Programación web (TCP/IP, clientes y servidores TCP, HTTP con [HttpClient], SMTP);
- Capítulo 13: Servicios web con Spring Boot;
- Capítulo 14: Para ir más lejos;
- Apéndices: Instalación de Laragon y MySQL, dependencias usadas por los proyectos Gradle.
1.3. El hilo conductor: el cálculo del impuesto
A lo largo de este documento se retoma un único problema: calcular el impuesto sobre la renta de un contribuyente que solo debe declarar su salario. La escala impositiva utilizada es la original (ingresos de 2003): ya no está vigente, pero basta para nuestro propósito, que es escribir la misma aplicación de varias maneras. Se implementa en nueve versiones:
Versión | Capítulo | Contenido |
1 | 3 | Un solo programa: entrada validada, cálculo, visualización |
2 | 4 | Clases e interfaces: [TaxBracket], [ITax], [AbstractTax], [HardwiredTax] |
3 | 5 | datos de cálculo leídos desde un archivo de texto o un archivo JSON |
4 | 6 | Una arquitectura en capas ([dao], [business], [ui]) dentro de un único programa |
5 | 6 | Un subproyecto Gradle por capa, pruebas unitarias e integración de las capas mediante inyección de dependencias |
6 | 10 | Una capa [dao] que lee los datos de una base de datos MySQL mediante JDBC |
7 | 11 | una capa [dao] escrita con Hibernate |
8 | 12 | Un servidor TCP de cálculo de impuestos y su cliente |
9 | 13 | un servicio web REST de cálculo de impuestos, un cliente de consola y un cliente web |
A partir de la versión 5, las versiones siguientes reutilizan las capas de la versión 5 y reemplazan solo la capa que cambia: este es todo el sentido de la arquitectura en capas presentada en el capítulo 6.
1.4. Ejemplos
El código de este documento está organizado en una única carpeta llamada [kotlin-oct-2026], con una subcarpeta por capítulo. Cada subcarpeta es un proyecto Gradle (o una compilación Gradle formada por varios proyectos) que puede abrirse tal cual en IntelliJ IDEA:
Cada programa pequeño es un archivo Kotlin, almacenado en un paquete que lleva su nombre ([src/main/kotlin/basics04/Basics04.kt], paquete [basics04]). Puede ejecutarlo en IntelliJ IDEA haciendo clic en el triángulo verde junto a su función [main], o desde la línea de comandos con Gradle ([gradlew -q run -Pmain=basics04.Basics04Kt], capítulo 2). Los programas que requieren una biblioteca externa (Jackson, JUnit, Spring, el controlador de MySQL, Hibernate, Spring Boot) deben declararla en el archivo [build.gradle.kts] de su proyecto: Gradle la descarga del repositorio Maven Central durante la primera compilación.
Todos los programas de este documento se compilaron sin errores ni advertencias con el compilador de Kotlin 2.4.20, usando la opción que trata todas las advertencias como errores ([allWarningsAsErrors]), y luego se ejecutaron en JDK 25. Los resultados reproducidos en este documento son los de esas ejecuciones. Los de los capítulos 2 a 4 se obtuvieron con la configuración regional de idioma y país francesa (fr-FR), como en una máquina Windows francesa: los números de punto flotante con formato se muestran con coma decimal y las fechas están en francés; los de los capítulos siguientes se obtuvieron con la configuración regional en inglés. Dos observaciones:
- los mensajes de error del compilador de Kotlin y del JDK (mensajes de excepción) están en inglés: no tienen traducción al francés;
- los ejemplos se ejecutaron en Linux. En su mayor parte, esto no supone ninguna diferencia: Kotlin en la JVM es multiplataforma. Las pocas diferencias (rutas de archivo con / en lugar de \, comandos de terminal, [./gradlew] en lugar de [gradlew]) se señalan donde aparecen.
Los resultados de los programas multihilo, asíncronos o de red, así como las duraciones medidas, pueden variar de una ejecución a otra: los comentarios se centran en lo que es reproducible.
1.5. Fuentes
Las fuentes principales de este documento son:
- la documentación oficial de Kotlin: el sitio web https://kotlinlang.org/docs (guía del lenguaje, tutoriales, páginas “What’s New” de cada versión) y la documentación de la biblioteca estándar: https://kotlinlang.org/api/core/kotlin-stdlib/;
- la guía de corrutinas: https://kotlinlang.org/docs/coroutines-guide.html;
- las propuestas de evolución del lenguaje (KEEP): https://github.com/Kotlin/KEEP;
- la documentación de Java, API y SE 25, para las clases del JDK: https://docs.oracle.com/en/java/javase/25/;
- la documentación de Gradle (https://docs.gradle.org) y la documentación de cada biblioteca: JUnit (https://docs.junit.org), Spring (https://spring.io/projects), Hibernate (https://hibernate.org/orm/documentation/), Jackson (https://github.com/FasterXML/jackson);
- dos libros de referencia: “Kotlin in Action” de Sebastian Aigner, Roman Elizarov, Svetlana Isakova y Dmitry Jemerov (Manning, 2.ª edición) y “Effective Kotlin” de Marcin Moskała; sobre hilos, “Java Concurrency in Practice” de Brian Goetz et al. (Addison-Wesley) sigue siendo una excelente lectura.