Skip to main content

Punto de entrada

⏱ Dedicación recomendada: 0 minutos
Esto considera el contenido visible y relevante, e ignora texto colapsado o marcado como opcional.

Antes de comenzar a construir bibliotecas reutilizables, es importante comprender cómo se ejecuta un programa en Kotlin. Aunque este curso se enfoca en el diseño de componentes modulares y reutilizables, conocer el punto de entrada del programa —la función main— resulta clave para realizar pruebas rápidas, crear ejemplos ilustrativos y desarrollar utilidades auxiliares.

En esta lección, aprenderemos cómo definir y ejecutar un programa Kotlin desde la línea de comandos. Exploraremos cómo imprimir mensajes en la consola, recibir argumentos desde la terminal y utilizar Gradle para compilar y ejecutar nuestros programas.

Estos conocimientos nos permitirán establecer una base sólida para experimentar con el lenguaje y documentar nuestras bibliotecas de forma interactiva y reproducible.

🚪 Función main​

La función main es el punto de entrada de cualquier programa ejecutable en Kotlin. A continuación, se muestra un ejemplo simple inspirado en una galaxia muy, muy lejana:

Función main con mensaje multilínea (app/src/main/kotlin/com/github/username/app.kt)
package com.github.username

fun main() {
    val message = """
        Hello there.
        General Kenobi!
        You are a bold one.
    """.trimIndent()

    println(message)
}
¿Qué acabamos de hacer?

Este programa imprime un mensaje multilínea en la consola utilizando println.

  • message se define como un bloque de texto usando triple comillas ("""), lo que permite conservar saltos de línea.
  • El método trimIndent() elimina la indentación común al inicio de cada línea, dejando el texto más limpio.
  • Finalmente, println(message) imprime el contenido en la consola, seguido de un salto de línea automático.

Esta técnica resulta útil para representar texto de forma clara y legible, especialmente en ejemplos, banners o mensajes con formato.

Aunque el enfoque de este curso está en el diseño de bibliotecas reutilizables, comprender el rol de la función main es fundamental. Nos permitirá construir ejemplos ilustrativos, ejecutar experimentos rápidos y validar comportamientos antes de formalizar una API.

Más adelante, adoptaremos las pruebas automatizadas como principal herramienta de verificación, lo que reducirá el uso cotidiano de main. Sin embargo, seguirá siendo un recurso valioso para exploración interactiva y documentación ejecutable.

println como expresión

En Kotlin, println es una función que devuelve un valor de tipo Unit, por lo que puede usarse como una expresión, no solo como una instrucción.

Gracias a esto, podemos definir la función main de forma más concisa utilizando la sintaxis de expresión única:

Versión concisa de main como expresión
fun main() = println("Hello, World!")

Aunque esta forma es perfectamente válida, no suele ser la más común para declarar main, ya que generalmente se prefiere la versión con bloques { ... } por claridad y flexibilidad.

Aun así, es útil conocer esta alternativa, especialmente para programas simples, scripts o ejemplos rápidos donde la brevedad es una ventaja.

println y print

El nombre println proviene de "print line", y su comportamiento refleja exactamente eso: imprime el texto seguido de un salto de línea.
En cambio, la función print imprime el texto tal como está, sin agregar un salto de línea al final.

Esto las hace útiles en distintos contextos, según si deseas continuar la salida en la misma línea o iniciar una nueva.

Diferencias entre print y println
for (i in 1..5) {
    print(i)     // Imprime: 12345 (todo en la misma línea)
}
println()        // Salto de línea manual
for (i in 1..5) {
    println(i)   // Imprime: 1\n2\n3\n4\n5 (cada número en una línea distinta)
}

En resumen, println("Texto") es equivalente a print("Texto\n").

▶️ Ejecutando el programa​

Para ejecutar la aplicación desde la terminal usando Gradle, utiliza el siguiente comando:

En tu terminal
./gradlew :app:run

Este comando compila el proyecto (si es necesario) y ejecuta la función main definida en el módulo app.

Salida esperada
> Task :app:run
Hello there.
General Kenobi!
You are a bold one.

Este enfoque es ideal para probar tu código rápidamente, sin necesidad de generar un archivo .jar ni configurar un entorno adicional.

Lo utilizaremos con frecuencia para ejecutar ejemplos y verificar el comportamiento de nuestras bibliotecas a medida que las desarrollamos.

¿Y si tengo más de una función main en el proyecto?

Veremos este tema en detalle más adelante, pero si necesitas cambiar la función main que se ejecuta, puedes modificar la siguiente línea dentro del bloque application de tu archivo build.gradle.kts:

build.gradle.kts
application {
    mainClass = "com.github.username.AppKt"
}

Sustituye "com.github.username.AppKt" por la ruta completa del archivo .kt que contiene la nueva función main, utilizando el formato que genera Kotlin al compilar:

  • Usa el nombre del paquete (por ejemplo, some.package)
  • Añade el nombre del archivo con la primera letra en mayúscula
  • Agrega el sufijo Kt, que Kotlin genera automáticamente para los archivos fuente

Por ejemplo, si tienes un archivo llamado otherMain.kt en app/src/main/kotlin/some/package/, deberías escribir:

mainClass = "some.package.OtherMainKt"

🧳 Función main con argumentos de línea de comandos​

La función main también puede recibir argumentos externos al momento de ejecutar el programa, lo que permite modificar su comportamiento según los valores proporcionados desde la terminal.

Aquí tienes un ejemplo básico:

Función main con argumentos (app/src/main/kotlin/com/github/username/app.kt)
fun main(args: Array<String>) {
    println("Welcome to Fabletown, ${args.joinToString(" ")}!")
}
¿Qué acabamos de hacer?

Este programa recibe argumentos desde la línea de comandos y los usa para personalizar un mensaje de bienvenida.

  • args: Array<String> es el parámetro que Kotlin pasa automáticamente a la función main. Contiene todos los valores ingresados después del nombre del ejecutable.
  • joinToString(" ") une los elementos del arreglo usando espacios. Así puedes aceptar nombres compuestos u otros argumentos sin preocuparte por la cantidad.
  • La llamada a println(...) imprime el resultado interpolado directamente en la consola.

Esta estrategia es más segura y flexible que acceder directamente a args[0], ya que evita errores cuando el usuario no proporciona argumentos o si estos contienen espacios.

🚀 ¿Cómo ejecutar este programa?​

Desde la raíz del proyecto, puedes pasar argumentos a la función main utilizando el plugin application de Gradle. Usa la opción --args, seguida de los argumentos entre comillas:

En tu terminal
./gradlew :app:run --args="Snow White"
📦 Salida esperada
> Task :app:run
Welcome to Fabletown, Snow White!
¿Qué acabamos de hacer?

La opción --args="..." permite enviar argumentos desde la terminal a la función main(args: Array<String>).

  • Los argumentos se separan por espacios dentro de las comillas.
  • Gradle se encarga de pasar el texto como un arreglo de cadenas a tu programa.
  • Es útil para realizar pruebas con distintos datos sin modificar el código fuente.

¡¿Eso es todo?!

—¡Ja! Apenas estoy calentando... —junta las manos y sonríe—
¡Compatibilidad con Java... activada!1

Aunque en Kotlin podemos declarar una función main sin clases, eso no basta si queremos:

  • Ejecutar el programa desde herramientas que esperan una clase con public static void main(String[] args) (como java -cp o scripts .bat/.sh).
  • Empaquetar un .jar ejecutable con Gradle y correrlo con java -jar.
  • Usar la app desde entornos que solo reconocen clases Java tradicionales (como algunas tareas de Maven o lanzadores de sistema operativo).
  • Integrar con herramientas como UIs o sistemas de CI que detectan entradas estáticas (por ejemplo, "Run Configurations" en IntelliJ para proyectos mixtos).
info

Para cubrir estos casos, necesitamos una función estática real de Java, algo que Kotlin no genera automáticamente... a menos que se lo pidamos explícitamente.

Para eso existe @JvmStatic:

Función main con @JvmStatic
object Launcher {
    @JvmStatic
    fun main(args: Array<String>) {
        println("Modo Java activado.")
    }
}

Esta anotación le indica al compilador que genere una función static verdadera dentro de la clase Launcher, compatible con cualquier herramienta que busque el clásico public static void main.

¿Cuándo es útil?
  • Si quieres distribuir tu herramienta como un .jar ejecutable.
  • Si necesitas que sea invocable desde Java o desde un script de shell.
  • Si trabajas en bibliotecas multiplataforma, herramientas CLI, plugins de build o lanzadores de sistema.

🎯 Conclusiones​

En esta lección exploramos el punto de entrada de los programas en Kotlin: la función main. Aprendimos cómo utilizarla para ejecutar pequeños programas, y cómo recibir argumentos desde la línea de comandos para adaptar dinámicamente el comportamiento del programa.

También repasamos funciones básicas como print y println, imprimimos mensajes con formato e indentación, y aprendimos a ejecutar la aplicación con Gradle, tanto con como sin argumentos.

🔑 Puntos clave​

  • La función main marca el inicio de cualquier programa ejecutable en Kotlin.
  • println imprime con salto de línea; print, sin él.
  • Es posible definir main como una expresión única si solo contiene una línea.
  • main puede recibir argumentos (args: Array<String>) desde la terminal.
  • Usar joinToString(" ") sobre args permite capturar múltiples palabras de forma segura.
  • Podemos ejecutar la aplicación y pasarle argumentos con:
    ./gradlew :app:run --args="..."

🧰 ¿Qué nos llevamos?​

Aunque el foco del curso está en el desarrollo de bibliotecas, comprender cómo funcionan los programas ejecutables nos permite construir ejemplos ilustrativos, scripts de prueba y herramientas auxiliares para el desarrollo.

Esta lección nos dio un primer contacto con elementos esenciales del lenguaje y con Gradle como sistema de construcción.
A medida que avancemos, la función main será menos frecuente, pero seguirá siendo una herramienta valiosa para crear experimentos interactivos, scripts internos y documentación ejecutable.

C++
Haskell
Python
Swift

📖 Referencias​

🔥 Recomendadas​

  • 🌐 "Hello world" de la documentación oficial de Kotlin: Introduce la función main y el uso de println en Kotlin, conceptos clave para comprender el punto de entrada de un programa ejecutable.
  • 🎥 "How to Run Kotlin Code Anywhere with Kotlin Main Functions" (53s) de Donn Felker: Demuestra cómo las funciones main pueden colocarse en cualquier archivo para pruebas rápidas en IntelliJ, reforzando su utilidad como herramienta exploratoria durante el desarrollo de bibliotecas.

🔹 Adicionales​

  • 🌐 "Your first program in Kotlin" en la documentación oficial de Android: Introducción práctica al punto de entrada en Kotlin desde la documentación oficial de Android. Este recurso guía al lector en la escritura de su primer programa, mostrando cómo definir funciones con fun, usar println para imprimir texto en consola, y comenzar a resolver errores comunes. Es relevante para esta lección porque refuerza la estructura básica de un programa ejecutable en Kotlin y promueve buenas prácticas como el estilo de nombres y la depuración inicial.
  • 🌐 "Basic syntax" de la documentación oficial de Kotlin: Revisión amplia de la sintaxis básica de Kotlin —incluyendo main, impresión y argumentos— útil como referencia general complementaria a esta lección y como base para explorar el lenguaje más allá del punto de entrada.
  • 📚 "Hello, World!" (pp. 26–28) en "Atomic Kotlin" de Bruce Eckel y Svetlana Isakova: Explicación gradual del punto de entrada en Kotlin desde un enfoque didáctico, útil como complemento narrativo y pedagógico a esta lección para quienes están comenzando.

Footnotes​

  1. Perdón. ↩