2. IntelliJ IDEA y Maven: el entorno de trabajo

Ficha de la sección

Campo	Valor
Unidad de Programación	UD1 — Fundamentos de Programación
Resultado de Aprendizaje	RA1 — Reconoce la estructura de un programa informático, identificando y relacionando los elementos propios del lenguaje de programación utilizado
Duración orientativa	Aproximadamente 3 de las 28 horas totales de UD1
Criterios de Evaluación implicados	CE 1.2 (Se han creado proyectos de desarrollo de aplicaciones) y CE 1.3 (Se han utilizado entornos integrados de desarrollo), ambos cubiertos de forma directa y completa en esta sección
Encaja en el roadmap	Es la sección "manos a la obra" de UD1: convierte en herramientas reales todo lo que en la Sección 1 fue teoría (JDK, JVM, bytecode). A partir de aquí, cada unidad del curso da por hecho que sabes moverte con soltura en IntelliJ y en Maven

Antes de empezar

En la Sección 1 aprendiste que un algoritmo es como una receta, y que Java compila tu código a bytecode que la JVM ejecuta en cualquier sistema operativo. Muy bien, pero hasta ahora todo ha sido teoría de cocina vista desde el sofá. Toca ponerse el delantal.

Para cocinar de verdad necesitas tres cosas: un horno (el motor que hace el trabajo pesado), una cocina bien equipada (un espacio cómodo donde trabajar sin perder tiempo buscando cada utensilio) y una forma ordenada de traer los ingredientes que no tienes en casa (en vez de ir tú personalmente al mercado cada vez que te falte algo). En esta sección vas a instalar exactamente eso, traducido al mundo Java:

El JDK 25 es tu horno: el motor que compila y ejecuta.
IntelliJ IDEA es tu cocina equipada: el entorno donde escribes, corriges y ejecutas código cómodamente.
Maven es tu gestor de almacén: organiza tu proyecto y trae automáticamente cualquier "ingrediente" (biblioteca externa) que necesites, sin que tengas que ir a buscarlo tú a mano.

flowchart TB
    JDK["JDK 25 (Adoptium Temurin)\nEl motor: compila y ejecuta"] --> IJ["IntelliJ IDEA Community\nEl taller: editor, autocompletado, ejecución con un clic"]
    IJ --> MVN["Maven\nEl gestor de almacén: organiza el proyecto y trae las piezas (dependencias)"]
    MVN --> PROJ["Tu proyecto Maven\nsrc/main/java + pom.xml"]

    style JDK fill:#1565c0,color:#fff,stroke:#0d47a1
    style IJ fill:#2e7d32,color:#fff,stroke:#1b5e20
    style MVN fill:#e65100,color:#fff,stroke:#bf360c
    style PROJ fill:#6a1b9a,color:#fff,stroke:#4a148c

Vamos con cada pieza, por orden.

2.1. Instalación de JDK 25 (Adoptium Temurin) e IntelliJ IDEA Community

¿Por qué "Adoptium Temurin" y no "el Java de Oracle"?

Java, como lenguaje y como especificación, es abierto: cualquier proveedor puede construir su propia distribución del JDK siempre que cumpla el estándar. Oracle tiene la suya (con condiciones de licencia que conviene revisar si algún día trabajas para una empresa), pero en este módulo usaremos Adoptium Temurin, una distribución totalmente gratuita, de código abierto y mantenida por la Eclipse Foundation, que es además una de las más usadas en el mundo profesional. La buena noticia es que el lenguaje que aprendes es exactamente el mismo, elijas la distribución que elijas: la especificación de Java no cambia entre proveedores.

Pasos conceptuales de instalación

Paso	Qué haces	Por qué es necesario
1	Descargar el instalador del JDK 25 (Temurin) desde la web oficial de Adoptium, eligiendo la versión correspondiente a tu sistema operativo	Es el componente que contiene `javac` (compilador), la JVM y todas las bibliotecas estándar
2	Ejecutar el instalador, dejando marcada la opción de añadirlo al `PATH` del sistema si el instalador la ofrece	El `PATH` es lo que permite que cualquier terminal, en cualquier carpeta, reconozca los comandos `java` y `javac` sin indicar la ruta completa
3	Abrir una terminal (símbolo del sistema, PowerShell o terminal de Linux/macOS) y ejecutar `java -version` y `javac -version`	Confirmar que el sistema operativo "ve" correctamente el JDK recién instalado. Deberías ver algo similar a `openjdk version "25" ...`
4	Descargar e instalar IntelliJ IDEA Community Edition desde la web oficial de JetBrains	Es el entorno de desarrollo (IDE) que usaremos durante todo el módulo
5	Abrir IntelliJ, ir a la configuración de SDKs del proyecto y comprobar que detecta o permite seleccionar el JDK 25 instalado	Asegurarte de que el "taller" (IntelliJ) y el "motor" (JDK) están correctamente conectados

Nota para el aula. Si java -version no reconoce el comando después de instalar el JDK, casi siempre es un problema del PATH del sistema operativo, no del JDK en sí. Es uno de los primeros "errores de bienvenida" con los que te vas a topar, y forma parte del aprendizaje: aprender a diagnosticar por qué el sistema operativo "no encuentra" algo que sí está instalado es una habilidad que vas a necesitar constantemente como desarrollador.

¿Y por qué no basta con el Bloc de Notas y una terminal?

Técnicamente, sí bastaría. Podrías escribir tu código en cualquier editor de texto plano y compilarlo y ejecutarlo a mano con javac y java desde la terminal. De hecho, es un ejercicio sano hacerlo alguna vez para entender que un IDE no es magia, solo comodidad. Pero un IDE como IntelliJ te da, entre otras cosas:

Autocompletado de código y detección de errores mientras escribes (antes incluso de compilar).
Ejecución y depuración con un solo clic o atajo de teclado.
Integración directa con Maven, con el control de versiones (Git) y con los tests (JUnit, que verás en UD2).
Refactorizaciones automáticas y navegación instantánea entre clases y métodos.

Es la diferencia entre conducir un coche con dirección asistida, GPS y sensores de aparcamiento, o hacerlo todo a pulso. Llegas al mismo sitio, pero de una forma bastante más razonable.

2.2. Crear un proyecto Maven desde cero

¿Qué problema resuelve Maven?

Imagina que tu programa necesita usar una biblioteca externa (por ejemplo, en UD2 usaremos JUnit para hacer pruebas). Sin Maven, tendrías que: buscar tú mismo el fichero .jar de esa biblioteca en algún sitio de Internet, descargarlo a mano, colocarlo en una carpeta de tu proyecto y configurar manualmente el "classpath" para que Java sepa dónde encontrarlo. Y si esa biblioteca depende a su vez de otras tres bibliotecas más (algo habitualísimo), tendrías que repetir el proceso con cada una de ellas.

Maven automatiza todo esto. Tú simplemente escribes en un fichero (pom.xml) qué necesitas, con su nombre y su versión, y Maven se encarga de: descargarlo desde un repositorio central (Maven Central, el "supermercado" oficial de bibliotecas Java), descargar también todo lo que esa biblioteca necesita a su vez, y dejarlo todo disponible para tu proyecto sin que tengas que tocar una sola carpeta a mano.

	Sin Maven (a mano)	Con Maven
Añadir una biblioteca externa	Buscarla, descargarla, copiarla en una carpeta, configurar el classpath	Escribir su nombre y versión en el `pom.xml`
Gestionar las dependencias de esa biblioteca	Repetir el proceso manualmente por cada una	Automático
Compilar el proyecto	Comando `javac` con rutas manuales para cada fichero	`mvn compile`
Estructura de carpetas	La decides tú, distinta en cada proyecto	Estándar, igual en cualquier proyecto Maven del mundo
Compartir el proyecto con un compañero	Tiene que replicar tu configuración manual	Con el `pom.xml` y el código fuente, ya tiene todo lo necesario

Nota para el aula (por qué lo vemos ya, en UD1). Podríamos haber dejado Maven para más adelante, cuando el proyecto empezara a tener dependencias externas de verdad. Se ha decidido introducirlo desde la primera unidad porque es el estándar de la industria: cualquier empresa que use Java gestiona sus proyectos con Maven (o con su primo Gradle). Cuanto antes te acostumbres a esta estructura y a este flujo de trabajo, más natural te resultará el resto del curso, y más preparado llegarás al mundo laboral.

Estructura estándar de un proyecto Maven

Cuando creas un proyecto Maven (desde IntelliJ: File > New > Project, seleccionando Maven y el JDK 25 como SDK del proyecto), se genera siempre la misma estructura de carpetas, sea cual sea el proyecto:

flowchart TD
    ROOT["mi-proyecto/"] --> POM["pom.xml"]
    ROOT --> SRC["src/"]
    SRC --> MAIN["main/"]
    SRC --> TEST["test/"]
    MAIN --> JAVA["java/"]
    JAVA --> PKG["dam/programacion/ud1/"]
    PKG --> CLASS["HolaMundo.java"]
    TEST --> TJAVA["java/  (tests con JUnit, desde UD2)"]
    ROOT --> TARGET["target/  (se genera solo, no se toca a mano)"]
    TARGET --> CLASSES["classes/*.class  (bytecode compilado)"]

    style ROOT fill:#1565c0,color:#fff,stroke:#0d47a1
    style POM fill:#e65100,color:#fff,stroke:#bf360c
    style TARGET fill:#616161,color:#fff,stroke:#333
    style CLASSES fill:#616161,color:#fff,stroke:#333

Carpeta o fichero	Qué contiene
`pom.xml`	El fichero de configuración del proyecto: qué es, qué versión de Java usa, qué dependencias necesita
`src/main/java/`	Tu código fuente "de verdad", el que forma parte de la aplicación
`src/test/java/`	El código de las pruebas automáticas (a partir de UD2, con JUnit 5)
`target/`	Carpeta generada automáticamente por Maven al compilar. Aquí aparece el bytecode (`.class`). Nunca se edita a mano y ni siquiera se sube al control de versiones

Esta estructura, exactamente igual en cualquier proyecto Maven del mundo, es una de las razones por las que Maven ha triunfado: cualquier desarrollador que abra tu proyecto sabe automáticamente dónde está cada cosa, sin necesitar ninguna explicación previa.

2.3. El `pom.xml` explicado

POM son las siglas de Project Object Model: es la "ficha de identidad" de tu proyecto, escrita en formato XML. Vamos a ver un pom.xml mínimo, típico de esta primera unidad, y a diseccionarlo pieza a pieza:

<?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
                             http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>dam.programacion</groupId>
    <artifactId>ud1-fundamentos</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <properties>
        <maven.compiler.source>25</maven.compiler.source>
        <maven.compiler.target>25</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!-- Todavía no necesitamos ninguna dependencia externa.
             En UD2 añadiremos aquí JUnit 5 para hacer pruebas. -->
    </dependencies>

    <build>
        <plugins>
            <!-- Este plugin permite ejecutar la aplicación con "mvn exec:java" -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.5.0</version>
                <configuration>
                    <mainClass>dam.programacion.ud1.HolaMundo</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

Elemento	Qué significa	Analogía de cocina
`groupId`	Identifica quién produce el proyecto, normalmente en formato inverso a un dominio (`dam.programacion`)	El "apellido de familia": agrupa todos los proyectos de un mismo autor o centro
`artifactId`	El nombre concreto de este proyecto en particular	El "nombre de pila" del proyecto
`version`	La versión del proyecto. `SNAPSHOT` indica que está en desarrollo, sin publicar de forma definitiva	El número de edición: "1ª edición, en pruebas"
`packaging`	Qué tipo de artefacto final se genera (`jar` es lo habitual para aplicaciones normales)	El formato de presentación final del plato
`<properties>`	Ajustes generales del proyecto: versión de Java, codificación de caracteres...	Los ajustes generales de la cocina: temperatura del horno, unidades de medida
`<dependencies>`	Las bibliotecas externas que el proyecto necesita	La lista de la compra: ingredientes que no tienes en casa y hay que traer
`<build><plugins>`	Herramientas adicionales que amplían lo que Maven sabe hacer (compilar de una forma concreta, ejecutar, empaquetar...)	Los electrodomésticos extra: no vienen de serie en la cocina básica, los añades si los necesitas

Dato clave. Fíjate en el mainClass del plugin: dam.programacion.ud1.HolaMundo. Ese es el nombre completo (paquete + clase) de la clase que contiene el método main, el punto de entrada de tu programa. Ese mismo criterio de nomenclatura de paquetes (dam.programacion.udX, cambiando la X por el número de unidad) lo vamos a mantener durante todo el curso, para que cualquier proyecto de cualquier unidad sea reconocible de un vistazo.

2.4. Compilar con `mvn compile`, ejecutar con `mvn exec:java`

Ahora que ya tienes el pom.xml y tu clase HolaMundo.java dentro de src/main/java/dam/programacion/ud1/, es el momento de cerrar el círculo que empezaste a entender en la Sección 1: código fuente, bytecode, ejecución.

flowchart LR
    POM["pom.xml\n(la lista de la compra)"] --> CMD1["mvn compile"]
    CMD1 --> CLS["target/classes/*.class\n(bytecode)"]
    CLS --> CMD2["mvn exec:java"]
    CMD2 --> JVM["La JVM ejecuta el programa"]

    style POM fill:#e65100,color:#fff,stroke:#bf360c
    style CMD1 fill:#1976d2,color:#fff,stroke:#0d47a1
    style CLS fill:#6a1b9a,color:#fff,stroke:#4a148c
    style CMD2 fill:#1976d2,color:#fff,stroke:#0d47a1
    style JVM fill:#2e7d32,color:#fff,stroke:#1b5e20

Desde una terminal, situado en la carpeta raíz del proyecto (donde está el pom.xml):

# Compila el código fuente y genera el bytecode en target/classes
mvn compile

# Ejecuta el programa a través del plugin exec-maven-plugin,
# usando la clase indicada en <mainClass> del pom.xml
mvn exec:java

Al ejecutar mvn compile, Maven invoca por debajo al compilador javac sobre todos los ficheros de src/main/java, y deja el resultado (los .class, es decir, el bytecode del que hablamos en la Sección 1) dentro de target/classes. Al ejecutar mvn exec:java, se arranca una JVM que carga ese bytecode y ejecuta el método main de la clase indicada.

Dato clave. El botón verde de "Run" de IntelliJ (o el atajo Shift + F10, que veremos en el siguiente apartado) hace exactamente este mismo proceso por detrás, de forma automática: compila si hace falta y ejecuta. La ventaja de conocer también los comandos de Maven por terminal es que son exactamente los mismos que se usarían en un servidor de integración continua en una empresa real, donde no hay ningún IDE de por medio.

2.5. Atajos de teclado imprescindibles en IntelliJ IDEA

Un IDE se disfruta de verdad cuando dejas de perseguir menús con el ratón. Estos son los atajos que vas a usar literalmente todos los días desde la primera semana:

Atajo	Acción	Cuándo lo vas a usar
`Shift + F10`	Ejecutar el programa (Run)	Cada vez que quieras comprobar qué hace tu código
`Ctrl + Space`	Autocompletado de código	Constantemente: IntelliJ te sugiere clases, métodos y variables mientras escribes
`Alt + Enter`	Mostrar soluciones rápidas ("quick fix")	Cuando IntelliJ subraya algo en rojo (error) o amarillo (aviso) y te ofrece arreglarlo automáticamente
`Ctrl + Alt + L`	Reformatear el código automáticamente	Para mantener siempre una indentación limpia y consistente, sin esfuerzo manual
`Ctrl + /`	Comentar o descomentar la línea actual	Para desactivar temporalmente una línea de código sin borrarla
`Shift` (pulsada dos veces)	Buscar cualquier cosa en todo el proyecto ("Search Everywhere")	Cuando no recuerdes en qué fichero o clase está algo
`F8`	Depuración: avanzar a la siguiente línea sin entrar en los métodos ("Step Over")	Lo trabajaremos a fondo en UD3, al ver la depuración de errores

Mito frecuente. "Tengo que memorizar todos los atajos desde el primer día o no seré un buen programador." Falso, y es una fuente de ansiedad innecesaria. Los atajos se interiorizan con la repetición, no con la memorización forzada. Usa el ratón sin remordimientos las primeras semanas; en cuestión de un mes, tus dedos ya buscarán solos Shift + F10 antes de que tu cabeza termine de pensar "voy a ejecutar esto".

Resumen de la sección

Idea clave	En una frase
JDK 25 (Adoptium Temurin)	El motor: compilador y JVM. Se instala una vez en el sistema operativo
IntelliJ IDEA Community	El taller de trabajo: editor, autocompletado, ejecución e integración con Maven
Maven	El gestor de almacén: organiza el proyecto y trae dependencias automáticamente
`pom.xml`	La ficha de identidad del proyecto: quién lo hace, cómo se llama, qué versión de Java usa, qué necesita
Estructura `src/main/java`	Carpeta estándar e idéntica en cualquier proyecto Maven del mundo
`mvn compile` / `mvn exec:java`	Compilar a bytecode / ejecutar ese bytecode con la JVM
Atajos de IntelliJ	`Shift+F10` (ejecutar), `Ctrl+Space` (autocompletar), `Alt+Enter` (arreglar), `Ctrl+Alt+L` (formatear)

Comprueba lo que has entendido

Si el JDK es el motor, ¿qué papel juega exactamente IntelliJ IDEA en esta analogía, y qué pasaría si intentaras usar IntelliJ sin tener el JDK instalado?
¿Qué diferencia hay entre añadir una biblioteca externa "a mano" y añadirla mediante Maven?
¿Qué carpeta de un proyecto Maven contiene tu código fuente, y cuál se genera automáticamente y no debe tocarse a mano?
Ordena estos tres pasos: mvn exec:java, escribir el código en HolaMundo.java, mvn compile. ¿En qué orden lógico ocurren?

Qué viene ahora

Ya tienes el entorno de trabajo completo: JDK 25 instalado, IntelliJ IDEA configurado, y sabes crear y manejar un proyecto Maven. En la Sección 3 de UD1 vamos a abrir por fin HolaMundo.java y diseccionar línea a línea la estructura de un programa Java: la clase como contenedor, el método main como punto de entrada, las novedades de Java 25 como las unnamed classes, y las reglas de sintaxis y nomenclatura que vas a aplicar durante el resto del curso.