Skip to content

2. Configuración del entorno de desarrollo

El entorno de trabajo del desarrollador Java se compone de tres elementos independientes:

  • el JDK (“Java Development Kit”): el compilador [javac], la máquina virtual y el comando [java] que ejecuta los programas, las bibliotecas estándar de Java SE y herramientas como [jshell] o [jar];
  • una herramienta de construcción de proyectos, en este caso Maven: descarga las bibliotecas que necesita un proyecto, lo compila, ejecuta sus pruebas y lo empaqueta;
  • un editor o un IDE (Entorno de Desarrollo Integrado): [IntelliJ IDEA], [VS Code] con extensiones para Java, o [Eclipse]. El IDE se basa en el JDK y puede leer proyectos Maven.

Este documento usa los comandos [java], [javac] y [mvn] para todas las operaciones: funcionan igual en Windows, Linux y macOS, sea cual sea el editor que elija.

2.1. JDK 25

2.1.1. Instalación

Existen varias distribuciones del JDK, todas construidas a partir del código fuente de OpenJDK y equivalentes para nuestros fines. Recomendamos Eclipse Temurin, una distribución libre y de código abierto de la Fundación Eclipse, que puede descargarse en https://adoptium.net: allí, seleccione la versión 25—LTS—, el sistema operativo y el tipo de paquete (en Windows, un instalador [.msi]). En Windows, también puede instalarlo desde una terminal (PowerShell o símbolo del sistema) con el administrador de paquetes [winget]:

winget install EclipseAdoptium.Temurin.25.JDK

Debe seleccionar el JDK (que contiene todo) y no solo el JRE (que solo permite ejecutar programas ya compilados). Al instalar en Windows, marque las opciones que agregan el JDK a [PATH] y que definen la variable de entorno [JAVA_HOME]: Maven y los paquetes del IDE la utilizan para localizar el JDK. En Linux, el JDK está disponible en los repositorios de las principales distribuciones (por ejemplo, [sudo apt install openjdk-25-jdk] en Ubuntu).

Después de la instalación, abra una nueva terminal para comprobar que los comandos [java] y [javac] están disponibles y muestran la versión del JDK:

1
2
3
4
5
6
> java --version
openjdk 25.0.4.1 2026-08-18
OpenJDK Runtime Environment (build 25.0.4.1+1-1-24.04.4-Ubuntu)
OpenJDK 64-Bit Server VM (build 25.0.4.1+1-1-24.04.4-Ubuntu, mixed mode, sharing)
> javac --version
javac 25.0.4.1

Estos resultados se obtuvieron con el paquete del JDK de Ubuntu. Con Temurin, las líneas 2 y 3 indican [Temurin-25], y la versión exacta depende de la fecha de instalación: las actualizaciones de parches se publican cada trimestre. Todas las versiones 25.0.x del JDK son adecuadas para este documento. Varios JDK pueden coexistir en el mismo sistema: el primero que se encuentre en el directorio [PATH] responde al comando [java].

2.1.2. Comandos del JDK

El JDK ofrece numerosos comandos. Estos son los que usaremos:

Comando
Función
[java File.java]
compila en memoria y ejecuta un programa escrito en un archivo fuente (Java 11; varios archivos a partir de Java 22)
[javac -d classes File.java]
compila uno o varios archivos fuente y coloca los archivos [.class] resultantes en la carpeta [classes]
[java -cp classes ClassName]
ejecuta el método [main] de una clase compilada, buscada en la ruta de clases ([-cp])
[java -cp "lib/*" File.java]
ejecuta un archivo fuente que usa las bibliotecas (archivos [.jar]) de la carpeta [lib]
[jshell]
Intérprete interactivo: usted escribe instrucciones de Java y ve sus resultados de inmediato
[jar]
crea o lee un archivo [.jar] (un archivo ZIP de clases compiladas)

El intérprete [jshell] (Java 9) es útil para probar un método o una expresión sin escribir un programa:

> jshell
|  Welcome to JShell -- Version 25.0.4.1
|  For an introduction type: /help intro

jshell> 1 + 2
$1 ==> 3

jshell> var s = "Java " + 25
s ==> "Java 25"

jshell> s.length()
$3 ==> 7

jshell> /exit
|  Goodbye

2.2. Maven

2.2.1. Instalación

Una aplicación Java real utiliza bibliotecas que no forman parte del JDK: un controlador de base de datos, un framework de pruebas, Hibernate, Spring… Estas se distribuyen como archivos [.jar] a través de un repositorio público, Maven Central (https://central.sonatype.com). Una herramienta de construcción como Maven lee el archivo [pom.xml] de un proyecto para determinar qué bibliotecas necesita, las descarga (junto con las bibliotecas de las que dependen) y luego compila, prueba y empaqueta el proyecto. Otra herramienta muy utilizada, Gradle, cumple la misma función; este documento usa Maven.

Maven puede descargarse desde https://maven.apache.org/download.cgi como un archivo ZIP ([apache-maven-3.9.x-bin.zip]). Descomprímalo en una carpeta, por ejemplo [C:\Program Files\apache-maven-3.9.11], y agregue su subcarpeta [bin] a [PATH] (Windows: “Editar las variables de entorno del sistema”). En Linux, Maven está disponible en los repositorios de las distribuciones ([sudo apt install maven]). Compruebe la instalación en una nueva terminal:

1
2
3
4
5
6
> mvn -v
Apache Maven 3.9.11 (3e54c93a704957b63ee3494413a2b544fd3d825b)
Maven home: /opt/maven
Java version: 25.0.4.1, vendor: Ubuntu, runtime: /usr/lib/jvm/java-25-openjdk-amd64
Default locale: en_US, platform encoding: UTF-8
OS name: "linux", version: "6.18.44-fc-v64", arch: "amd64", family: "unix"

La línea 4 es importante: muestra el JDK utilizado por Maven, que está referenciado por la variable [JAVA_HOME]. Debe ser un JDK 25. Los paquetes de los IDE IntelliJ IDEA y VS Code incluyen su propio Maven: es suficiente si no usa Maven desde la línea de comandos.

Las bibliotecas descargadas por Maven se almacenan en la máquina local , en el repositorio local [%USERPROFILE%\.m2\repository] (Linux, macOS: [~/.m2/repository]). Se descargan una sola vez y luego las utilizan todos los proyectos. Por lo tanto, se requiere conexión a Internet al construir un proyecto por primera vez.

2.2.2. Comandos de Maven

El comando [mvn] va seguido de una o varias fases del ciclo de construcción, o de un objetivo (goal) de un plugin; se escribe en la carpeta que contiene el archivo [pom.xml]:

Comando
Función
[mvn compile]
compila el código fuente de [src/main/java]; las clases se organizan en [target/classes]
[mvn test]
compila y luego ejecuta las pruebas unitarias de [src/test/java] (capítulo 6)
[mvn package]
compila, prueba y crea el archivo del proyecto [.jar] en [target]
[mvn install]
igual que [package], y luego copia el archivo al repositorio local, donde otros proyectos pueden usarlo (capítulo 6)
[mvn clean]
elimina la carpeta [target]
[mvn compile exec:java]
compila y luego ejecuta la clase principal del proyecto (plugin [exec-maven-plugin])
[mvn spring-boot:run]
ejecuta una aplicación Spring Boot (capítulo 13)

Las fases son secuenciales: ejecutar [package] activa también [compile] y [test]. La opción [-q] (“quiet”) suprime los mensajes de Maven y muestra solo los del programa ejecutado; la opción [-Dexec.args="a b"] pasa argumentos al programa iniciado por [exec:java].

2.3. El editor

2.3.1. IntelliJ IDEA

IntelliJ IDEA, de la empresa JetBrains, es el editor de Java más utilizado. Sus funciones básicas, más que suficientes para este documento, son gratuitas. Es compatible con los proyectos Maven: seleccione “File / Open” y luego elija la carpeta que contiene el archivo [pom.xml]; IntelliJ descarga las bibliotecas, compila el proyecto y permite ejecutar una clase haciendo clic en el triángulo verde del margen junto a su método [main] ([Ctrl-Shift-F10]), o ejecutar una prueba haciendo clic en el mismo triángulo junto al método de prueba. Indique el JDK que se usará en “File / Project Structure / SDK”.

Puede abrir de una vez toda la carpeta de ejemplos [java-oct-2026] (“File / Open”): IntelliJ detecta allí todos los proyectos Maven y los muestra en su panel “Maven”. En este punto es necesaria una precaución. Los proyectos de los capítulos 10 a 13 (versiones 6 a 9 de la aplicación [Tax]) usan los módulos [tax-dao], [tax-business] y [tax-ui] de la versión 5, escrita en el capítulo 6. No son bibliotecas públicas: Maven solo puede encontrarlos en el repositorio local si se han instalado allí. Por lo tanto, debe comenzar instalando la versión 5: en el panel “Maven”, expanda [tax-v5] / "Lifecycle" y haga doble clic en [install] (o escriba [mvn install] en la carpeta [06-architectures/TaxV5]), y luego haga clic en el botón "Sync All Maven Projects" del panel. El capítulo 6 explica qué hace este comando y qué hacer si IntelliJ sigue informando dependencias no resueltas.

2.3.2. VS Code

VS Code es un editor gratuito y multiplataforma. Para programar en Java, puede instalar el Extension Pack for Java de Microsoft (vaya al menú “Extensions” y busque “Extension Pack for Java”), que incluye soporte del lenguaje, depurador, ejecución de pruebas y soporte de Maven. Esto proporciona:

  • resaltado de sintaxis, autocompletado de código y ayuda contextual;
  • detección de errores mientras se escribe;
  • navegación por el código (F12: ir a la definición);
  • ejecución y depuración (los enlaces “Run” y “Debug” sobre cada método [main] o F5);
  • ejecución de pruebas unitarias (la vista “Testing”) y una vista “Maven” de los proyectos.

En VS Code, abra la carpeta que contiene los programas (“File / Open Folder”), por ejemplo, la carpeta [java-oct-2026] con los ejemplos de este documento. La terminal integrada (“Terminal / New Terminal”) permite escribir los comandos [java] y [mvn] sin salir del editor.

2.3.3. Eclipse

Una tercera opción es el IDE de código abierto Eclipse (https://eclipseide.org), históricamente el primer gran IDE de Java, que también importa proyectos Maven (“File / Import / Maven / Existing Maven Projects”).

En el resto de este documento, las operaciones se describen con los comandos [java], [javac] y [mvn], que producen los mismos resultados sea cual sea el editor.

2.4. Un primer programa: un archivo fuente compacto

2.4.1. El programa

A partir de Java 25, un programa Java puede ser un simple archivo que contiene un único método [main], sin declaración de clase. Esto se denomina “archivo fuente compacto”. Creemos el siguiente archivo [Hello.java]:

1
2
3
4
// primer programa Java: un archivo fuente compacto
void main() {
    IO.println("1st try with Java 25");
}

y ejecutémoslo:

> java Hello.java
1st try with Java 25

Comentarios:

  • línea 1: un comentario. Todo lo que sigue a [//] hasta el final de la línea es ignorado por el compilador;
  • línea 2: el método [main], el punto de entrada del programa. En un archivo fuente compacto, no necesita declararse en una clase, ni tiene que ser [public] y [static], ni tiene que recibir los argumentos del programa; veremos en el capítulo 3 que el propio compilador lo envuelve en una clase;
  • línea 3: la única instrucción del programa: imprime una línea de texto en la pantalla. La clase [IO] (Java 25) ofrece métodos sencillos para escribir ([print], [println]) y para leer ([readln]) desde el teclado;
  • el comando [java Hello.java] compila el programa en memoria, sin crear un archivo [.class], y luego lo ejecuta. Esta capacidad de ejecutar directamente un archivo fuente se introdujo en Java 11.

El nombre del archivo debe ser un identificador Java válido: [Hello.java] o [Basics01.java] son aceptables, pero [basics-01.java] es rechazado por el compilador ([bad file name]) porque el nombre del archivo se convierte en el nombre de la clase generada. Por convención, los nombres de las clases, y por lo tanto los de los archivos, comienzan con mayúscula.

También puede compilar el programa con [javac], que produce un archivo [.class], y luego ejecutar este archivo compilado:

1
2
3
4
5
> javac -d classes Hello.java
> dir classes (list of files)
Hello.class
> java -cp classes Hello
1st try with Java 25

El archivo [Hello.class] contiene el bytecode de la clase [Hello] generada por el compilador. El comando [java -cp classes Hello] indica a la máquina virtual que ejecute el método [main] de la clase [Hello], que se encuentra en la carpeta [classes].

Los archivos fuente compactos son adecuados para programas pequeños, y los usaremos en la mayoría de los ejemplos. Cuando un programa requiere una biblioteca externa, aún se puede iniciar con el comando [java -cp "lib/*" Program.java] si ha copiado los archivos [.jar] de la biblioteca (y los de las que depende) en una carpeta [lib]. Pero reunir estos archivos a mano resulta tedioso muy rápidamente, así que escribiremos un proyecto Maven.

En Windows, los caracteres acentuados escritos con [IO.println] o [System.out.println] se muestran correctamente en la terminal: Java convierte el texto a la codificación de la terminal. Los archivos fuente deben guardarse en UTF-8, la codificación predeterminada de VS Code e IntelliJ IDEA, y la que el compilador asume a partir de Java 18.

2.5. Un proyecto Maven

2.5.1. Estructura del proyecto

Un proyecto Maven es una carpeta que contiene un archivo [pom.xml] (“Project Object Model”) y archivos fuente organizados según una estructura de directorios estándar. El proyecto [FirstProgram] de la carpeta [02-installation] es el siguiente:

1
2
3
4
5
6
7
FirstProgram/
├── pom.xml
└── src/
    └── main/
        └── java/
            └── first/
                └── Main.java
  • [src/main/java] contiene los archivos fuente del programa; [src/main/resources] contiene los archivos de datos o de configuración que se colocan junto a las clases compiladas; [src/test/java] contiene las pruebas (capítulo 6);
  • Dentro de [src/main/java], la estructura de carpetas refleja la de los paquetes (capítulo 4): la clase [first.Main] se encuentra en la carpeta [first].

Puede crear esta estructura de directorios manualmente, o dejar que el IDE la cree (IntelliJ: “File / New / Project”, seleccione “Maven” como sistema de construcción). El archivo [pom.xml] es el siguiente:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- las coordenadas del proyecto -->
    <groupId>examples.installation</groupId>
    <artifactId>first-program</artifactId>
    <version>1.0</version>

    <properties>
        <!-- versión de Java de destino y codificación del archivo fuente -->
        <maven.compiler.release>25</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <build>
        <plugins>
            <!-- el compilador, con todas las advertencias -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.15.0</version>
                <configuration>
                    <compilerArgs>
                        <arg>-Xlint:all</arg>
                    </compilerArgs>
                </configuration>
            </plugin>
            <!-- mvn exec:java ejecuta la clase principal -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.5.1</version>
                <configuration>
                    <mainClass>first.Main</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
  • Líneas 8–10: las coordenadas del proyecto, que lo identifican de forma única: el grupo ([groupId], a menudo un nombre de dominio invertido como [org.hibernate]), el nombre del proyecto ([artifactId]) y su versión. Estos son también los identificadores que otro proyecto usará para referenciar a este si es necesario, de la misma manera que se referencia una biblioteca de Maven Central (capítulo 6);
  • línea 14: el código se compila para Java 25;
  • línea 15: los archivos fuente están escritos en UTF-8;
  • líneas 21–30: el plugin de compilación, con la opción [-Xlint:all], que activa todas las advertencias del compilador;
  • líneas 32–39: el plugin [exec-maven-plugin], que permite ejecutar la clase principal del proyecto, especificada en la línea 37, con el comando [mvn exec:java].

Este proyecto no usa ninguna biblioteca. Un proyecto que usa una biblioteca la declara en una sección [<dependencies>] mediante sus coordenadas, como haremos a partir del capítulo 5:

1
2
3
4
5
6
7
<dependencies>
    <dependency>
        <groupId>tools.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>3.1.5</version>
    </dependency>
</dependencies>

El archivo [Main.java] contiene el programa en su forma estándar, con una clase [public] y un método [public static void main(String[] args)]:

1
2
3
4
5
6
7
8
9
package first;

// el programa principal del proyecto [FirstProgram]
public class Main {

    public static void main(String[] args) {
        System.out.println("1st try with a Maven project / Java 25");
    }
}
  • línea 1: la clase pertenece al paquete [first]; su nombre completo es [first.Main];
  • líneas 4–9: la clase [Main]. Un archivo fuente contiene como máximo una clase pública, que lleva el nombre del archivo;
  • líneas 6–8: el método [main], en la forma que ha tenido desde la primera versión de Java. Compararemos las dos formas en el capítulo 3.

2.5.2. Compilación y ejecución

El comando [mvn compile], escrito en la carpeta del proyecto, compila el proyecto: Maven descarga los plugins necesarios según haga falta, luego compila los archivos de [src/main/java] y coloca las clases resultantes en la carpeta [target/classes], conservando la jerarquía de paquetes ([target/classes/first/Main.class]). El comando [mvn compile exec:java] compila el proyecto y luego lo ejecuta; con la opción [-q], solo se muestra la salida del programa:

> mvn -q compile exec:java
1st try with a Maven project / Java 25

Una vez compilado el proyecto, también puede ejecutar la clase directamente con el comando [java], indicando la ubicación de las clases:

> java -cp target/classes first.Main
1st try with a Maven project / Java 25

La carpeta [target] puede eliminarse sin problema ([mvn clean]): se volverá a crear en la siguiente compilación. El comando [mvn package] también produce el archivo [target/first-program-1.0.jar], que puede ejecutarse con [java -cp target/first-program-1.0.jar first.Main]: este es el formato en el que se entrega un programa Java.

2.6. Un proyecto con varios módulos

2.6.1. El proyecto agregador

Un proyecto Maven puede agrupar otros proyectos, llamados sus módulos. La carpeta [02-installation] contiene un archivo llamado [pom.xml] que agrupa sus dos proyectos:

<?xml version="1.0" encoding="UTF-8"?>
<!-- un proyecto "agregador": agrupa los proyectos de la carpeta para compilarlos juntos -->
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>examples.installation</groupId>
    <artifactId>installation</artifactId>
    <version>1.0</version>
    <packaging>pom</packaging>

    <modules>
        <module>FirstProgram</module>
        <module>TwoHands</module>
    </modules>
</project>
  • Línea 11: este proyecto no produce un archivo [.jar]: solo sirve para agrupar otros proyectos ([pom]);
  • Líneas 13–16: los módulos, identificados por los nombres de sus carpetas.

En la carpeta [02-installation], el comando [mvn compile] compila los dos proyectos; un comando del IDE que abre esta carpeta ve ambos proyectos a la vez. En el capítulo 6 veremos que un proyecto padre también puede transmitir una configuración común (versiones de bibliotecas, opciones del compilador) a sus módulos.

2.6.2. Un proyecto con varios métodos main

Un proyecto puede contener varias clases, cada una con un método [main] : cada una es un posible punto de entrada, y la clase que se ejecutará se elige en tiempo de ejecución. El proyecto [TwoHands] contiene dos clases. La clase [P1]:

1
2
3
4
5
6
7
8
package twohands;

public class P1 {

    public static void main(String[] args) {
        System.out.println("main of the class P1");
    }
}

y la clase [P2], que es idéntica salvo por su nombre. El comando [java] ejecuta la clase especificada:

1
2
3
4
> java -cp target/classes twohands.P1
main of the class P1
> java -cp target/classes twohands.P2
main of the class P2

Para el comando [mvn exec:java], el archivo de proyecto [pom.xml] especifica la clase que se ejecutará:

1
2
3
4
5
6
7
8
9
            <!-- la clase cuyo método main ejecuta mvn exec:java -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.5.1</version>
                <configuration>
                    <mainClass>twohands.P2</mainClass>
                </configuration>
            </plugin>
  • Línea 7: el método [main] que se ejecuta pertenece a la clase [twohands.P2] (el nombre completo de la clase, incluido el paquete).

Resultados:

> mvn -q compile exec:java
main of the class P2

Puede elegir otra clase sin modificar el archivo [pom.xml]: [mvn -q exec:java -Dexec.mainClass=twohands.P1].

2.7. Los ejemplos del documento

Para ejecutar los ejemplos de este documento:

  • descargue la carpeta [java-oct-2026] (enlace al comienzo del documento);
  • ábrala en VS Code (“File / Open Folder”) o, para un proyecto Maven determinado, abra su carpeta en IntelliJ IDEA;
  • en una terminal ubicada en la carpeta de un capítulo, ejecute un archivo fuente compacto con [java Name.java], o un proyecto Maven con [mvn -q compile exec:java] en la carpeta del proyecto (el texto de cada capítulo indica el comando exacto).

Los capítulos 10 y 11 usan una base de datos llamada MySQL; la instalación de MySQL junto con [Laragon] se describe en el apéndice.