Tutorial Kotlin: Instalación y primer programa de Kotlin

Estructura básica de un proyecto Kotlin

En Kotlin, la estructura típica de un proyecto sigue convenciones comunes en el ecosistema de la JVM. Es fundamental entender esta organización para facilitar el mantenimiento y escalabilidad del código.

Un proyecto Kotlin suele tener el siguiente árbol de directorios:

mi-proyecto/
├── build.gradle.kts
├── settings.gradle.kts
└── src/
    ├── main/
    │   ├── kotlin/
    │   │   └── com/
    │   │       └── ejemplo/
    │   │           └── App.kt
    │   └── resources/
    └── test/
        ├── kotlin/
        └── resources/

El directorio src contiene todo el código fuente y los recursos necesarios para el proyecto. Dentro de src, encontramos dos subdivisiones principales: main y test.

• main: Aquí se ubica el código fuente de la aplicación. El subdirectorio kotlin alberga los archivos .kt y sigue la estructura de paquetes definida por la aplicación. Por ejemplo, el paquete com.ejemplo se corresponde con la ruta de directorios com/ejemplo/.
• resources: Este directorio contiene los recursos estáticos necesarios en tiempo de ejecución, como archivos de configuración, imágenes o archivos de texto.
• test: En esta sección se coloca el código dedicado a las pruebas unitarias y de integración. La organización es similar a la de main, con directorios kotlin y resources.
• Los archivos build.gradle.kts y settings.gradle.kts son los scripts de configuración del sistema de compilación Gradle, utilizando el lenguaje Kotlin para su definición. Esto permite aprovechar las ventajas de la tipificación y autocompletado en el IDE.

Es importante mantener una estructura coherente en los paquetes para reflejar la lógica del dominio de la aplicación. Esto facilita la navegación y comprensión del código por parte de otros desarrolladores.

Un ejemplo de un archivo Kotlin básico podría ser:

fun main() {
    println("Bienvenidos a Kotlin")
}

En este fragmento, la función main es el punto de entrada de la aplicación. El paquete com.ejemplo se alinea con la ubicación del archivo dentro del directorio src/main/kotlin/com/ejemplo/.

Para gestionar las dependencias y configuraciones adicionales, el archivo build.gradle.kts podría incluir:

plugins {
    kotlin("jvm") version "1.10.0"
}

repositories {
    mavenCentral()
}

dependencies {
    implementation(kotlin("stdlib"))
    testImplementation(kotlin("test"))
}

Este script define que el proyecto utiliza el plugin Kotlin JVM y especifica las dependencias necesarias, como la biblioteca estándar. También configura el repositorio Maven Central para resolver las dependencias.

Al seguir esta estructura estándar, se asegura la compatibilidad con herramientas y prácticas comunes en el ecosistema de Kotlin y la JVM. Además, los entornos de desarrollo integrados (IDE) como IntelliJ IDEA reconocen automáticamente esta organización, lo que mejora la productividad.

Hola mundo en Kotlin

Para iniciar con Kotlin, es habitual crear un programa básico que imprima "Hola mundo" en la consola. Este ejercicio permite familiarizarse con la sintaxis y estructura del lenguaje de una forma sencilla.

En Kotlin, la función principal desde la cual se ejecuta el programa se denomina main. A continuación, se presenta el código mínimo necesario para mostrar "Hola mundo":

fun main() {
    println("Hola mundo")
}

En este ejemplo:

• fun es la palabra clave utilizada para declarar una función.
• main es el nombre de la función principal que el compilador reconoce como punto de entrada del programa.
• println es una función integrada que imprime el mensaje proporcionado seguido de un salto de línea.

Es importante destacar que la función main puede tener una variante que acepta argumentos de línea de comandos:

fun main(args: Array<String>) {
    println("Hola mundo")
}

Aquí, args es un arreglo de cadenas (Array<String>) que contiene los argumentos proporcionados al ejecutar el programa desde la terminal.

Además, Kotlin permite omitir explicitamente el tipo de retorno de la función main, ya que se infiere como Unit, equivalente a void en otros lenguajes. Esto simplifica el código y lo hace más conciso.

Al escribir código en Kotlin, es recomendable seguir las convenciones oficiales de estilo para garantizar la legibilidad y mantenibilidad del código. Esto incluye el uso de espacios, indentación de cuatro espacios y nombrado coherente de funciones y variables.

Finalmente, es buena práctica comentar el código para facilitar su comprensión. Kotlin soporta comentarios de una línea y de bloque:

• Comentario de una línea:

// Esto es un comentario de una sola línea

• Comentario de bloque:

/*
* Esto es un comentario
* de varias líneas
*/

Con este conocimiento, podrás continuar y explorar funcionalidades más avanzadas de Kotlin, construyendo programas más complejos y aprovechando al máximo las características que ofrece el lenguaje.

Compilación y ejecución

Una vez que hayas escrito tu código Kotlin, el siguiente paso es compilar y ejecutar tu programa para verificar su funcionamiento. Kotlin ofrece diferentes formas de compilación y ejecución, ya sea a través de la línea de comandos o utilizando herramientas de construcción como Gradle.

Para ejecutar este programa:

Asegúrate de tener instalado el compilador de Kotlin en tu sistema.

Para ello deberás tener instalado java sdk para el sistema operativo que utilices, cuando lo tengas simplemente deberás añadir el siguiente comando:

Guarda el código en un archivo con extensión .kt, por ejemplo, HolaMundo.kt.

Compila el archivo utilizando el comando:

Este comando compila el código y genera un archivo HolaMundo.jar que incluye el runtime de Kotlin.

Ejecuta el programa con:

java -jar HolaMundo.jar

Al hacerlo, verás el mensaje "Hola mundo" en la consola.

Para ocasiones en las que se desea probar código rápidamente, Kotlin permite la creación de scripts. Un script es un archivo con extensión .kts que se puede ejecutar directamente sin compilación previa:

// HolaMundo.kts
println("Hola mundo")

Ejecuta el script utilizando el comando:

kotlinc -script HolaMundo.kts

Este enfoque es útil para tareas simples o prototipado rápido, ofreciendo una mayor flexibilidad.

Si tu proyecto consta de múltiples archivos y paquetes, es conveniente compilar todos los archivos a la vez. Puedes compilar todo el contenido de un directorio específico:

kotlinc src -include-runtime -d MiProyecto.jar

Aquí, src es el directorio que contiene todo el código fuente. Asegúrate de que la estructura de directorios refleja correctamente los paquetes definidos en tu código.

Compilar con Gradle

Otra alternativa es utilizar una herramienta de construcción como Gradle, que simplifica el proceso de compilación y gestión de dependencias. Si ya has configurado tu proyecto con Gradle, puedes compilar y ejecutar tu programa con los siguientes comandos:

• Para compilar el proyecto:

./gradlew build

Este comando genera los archivos compilados y empaqueta el proyecto.

• Para ejecutar el programa:

./gradlew run

Este comando compila y ejecuta la aplicación en un solo paso. Es especialmente útil durante el desarrollo, ya que automatiza el proceso.

En proyectos que requieren pruebas automatizadas, puedes ejecutar todas las pruebas con:

./gradlew test

Esto asegurará que tu código cumple con los criterios establecidos en tus pruebas unitarias.

Kotlin REPL

Si prefieres probar pequeñas porciones de código o funciones específicas, Kotlin ofrece un REPL (Read-Eval-Print Loop) interactivo. Para iniciarlo, simplemente ejecuta:

kotlinc

Aparecerá un prompt donde puedes escribir código Kotlin y verlo evaluado inmediatamente. Por ejemplo:

>>> val saludo = "Hola, Kotlin"
>>> println(saludo)

El REPL es una herramienta excelente para experimentar y prototipar rápidamente sin la necesidad de crear archivos o proyectos completos.

En entornos de desarrollo integrados como IntelliJ IDEA, la compilación y ejecución se manejan de forma más intuitiva. Puedes ejecutar tu programa directamente desde el IDE, lo que facilita el proceso de desarrollo y depuración. Asegúrate de configurar correctamente la configuración de ejecución para que el IDE sepa cuál es tu función main o punto de entrada del programa.

Es importante tener en cuenta las rutas de los paquetes y clases al compilar desde la línea de comandos. Si tus clases están en paquetes, deberás especificar la ruta completa al ejecutar el programa. Por ejemplo:

java -cp . com.ejemplo.AppKt

Aquí, -cp . indica que el classpath es el directorio actual, y com.ejemplo.AppKt es el nombre completo de la clase generada por el compilador de Kotlin. El sufijo Kt es añadido automáticamente por el compilador para las clases que contienen funciones main de nivel superior.

Para proyectos más complejos, es recomendable familiarizarse con las opciones avanzadas del compilador y las configuraciones de Gradle o Maven. Esto incluye la gestión de dependencias externas, configuraciones de compilación específicas y la optimización del proceso de construcción.

Finalmente, recuerda que mantener tu entorno de desarrollo y tus herramientas actualizadas es crucial. Asegúrate de utilizar la versión más reciente del compilador de Kotlin y de Gradle para aprovechar las últimas características y mejoras de rendimiento. Consultar regularmente la documentación oficial de Kotlin te ayudará a estar al día con las mejores prácticas y novedades del lenguaje.

Paquetes e importaciones

En Kotlin, los paquetes son fundamentales para organizar el código y evitar conflictos entre nombres de clases o funciones. Un paquete agrupa elementos relacionados, facilitando la gestión y lectura del código en proyectos de cualquier tamaño.

Para declarar un paquete en un archivo Kotlin, se utiliza la palabra clave package seguida del nombre del paquete:

package com.ejemplo.proyecto

Esta declaración debe colocarse al inicio del archivo, antes de cualquier otra instrucción. El nombre del paquete sigue la convención de dominio invertido, lo que garantiza la unicidad y coherencia en la estructura del proyecto.

La estructura de directorios debe reflejar la jerarquía de paquetes. Por ejemplo, para el paquete com.ejemplo.proyecto, el archivo Kotlin correspondiente se ubicará en src/main/kotlin/com/ejemplo/proyecto/.

Cuando es necesario utilizar clases o funciones de otros paquetes, se emplean las importaciones. La palabra clave import permite acceder a estos elementos sin necesidad de escribir su ruta completa cada vez:

import com.utilidades.FuncionUtil

Con esta importación, puedes usar FuncionUtil directamente en tu código. Si deseas importar todas las clases y funciones de un paquete, puedes utilizar el comodín *:

import com.utilidades.*

Sin embargo, es recomendable ser específico en las importaciones para mejorar la legibilidad y evitar posibles conflictos de nombres.

Kotlin permite asignar alias a las importaciones, lo que es útil cuando existen nombres duplicados o para simplificar referencias:

import com.utilidades.FuncionUtil as Utilidad

Ahora, puedes referirte a FuncionUtil simplemente como Utilidad en tu código, lo que puede mejorar la claridad en ciertos contextos.

Es importante destacar que Kotlin importa automáticamente las clases y funciones del paquete kotlin.*, por lo que elementos como String, Int o println están disponibles sin necesidad de una importación explícita.

Cuando trabajas con funciones o propiedades estáticas de una clase, puedes importarlas directamente:

import com.ejemplo.Constantes.PI
import com.ejemplo.Utilidades.calcularArea

De este modo, puedes utilizar PI y calcularArea sin precederlas del nombre de su clase, lo que hace el código más conciso.

Además, Kotlin soporta la importación de funciones y propiedades de extensión, lo que permite añadir funcionalidades a clases existentes:

import com.extensiones.formatearTexto

Así, puedes usar formatearTexto como si fuera una función miembro de la clase correspondiente, mejorando la extensibilidad del código.

Es posible organizar las importaciones en diferentes grupos y el orden recomendado es:

1. Importaciones estáticas y de nivel superior.
2. Importaciones de terceros.
3. Importaciones internas del proyecto.

Mantener un orden lógico en las importaciones contribuye a la organización general del código y facilita su mantenimiento.

En caso de conflictos de nombres entre diferentes paquetes, es esencial usar alias o referencias completas para evitar ambigüedades. Por ejemplo:

import com.ejemplo.clase.MiClase as ClaseEjemplo
import com.otroejemplo.clase.MiClase as ClaseOtroEjemplo

Esto permite diferenciar entre ClaseEjemplo y ClaseOtroEjemplo, asegurando que el código sea explícito y fácil de entender.

Finalmente, seguir buenas prácticas en el uso de paquetes e importaciones es clave para desarrollar aplicaciones Kotlin estructuradas y escalables. Organiza tus clases y funciones de manera lógica, utiliza importaciones claras y mantén la consistencia en todo el proyecto para lograr un código limpio y mantenible.