2. IntelliJ IDEA y Maven: el entorno de trabajo

UD1 — Fundamentos de Programación

IES Thiar · Curso 2026 - 2027

Aspecto	Valor
Resultado de aprendizaje	RA1 — Reconoce la estructura de un programa informático, identificando y relacionando los elementos propios del lenguaje de programación utilizado.
Criterios de evaluación cubiertos	CE 1.2 — Se han creado proyectos de desarrollo de aplicaciones. CE 1.3 — Se han utilizado entornos integrados de desarrollo.
Marco normativo	RD 405/2023 · RD 450/2010 · RD 659/2023
Herramientas instaladas	OpenJDK 25 LTS (Adoptium Temurin 25) · IntelliJ IDEA Community Edition · Apache Maven 3.9.x

---

Introducción de la sección

En la Sección 1 dejamos claro qué es programar y por qué Java es una buena elección. Ahora toca lo que de verdad duele al principio: configurar el entorno. Es la parte menos glamurosa del curso, pero también la que más frustración evita después. Si instalas bien las herramientas hoy, los próximos meses los pasas programando; si instalas mal, los pasas peleando con mensajes de error crípticos. Vale la pena invertir dos horas ahora para ahorrarse docenas más adelante.

El objetivo de esta sección es que termines con tres cosas funcionando en tu equipo: el JDK 25 instalado y reconocido en la consola, IntelliJ IDEA Community abierto con tu primer proyecto, y Maven gestionando las dependencias sin que tengas que descargar ningún fichero .jar a mano. Cuando acabes, escribirás tu primer programa en Java 25 (un Hola, mundo moderno sin clase ni static), lo compilarás y lo ejecutarás. Por el camino verás qué es un pom.xml, qué es el repositorio .m2 y por qué Maven es el jefe de cocina de cualquier proyecto Java profesional.

Deberás hacer estos pasos tanto en el equipo de trabajo como en casa para poder trabajar con las mismas herramientas.

---

2.1 Por qué un IDE y no un bloc de notas

Analogía

Podrías cocinar un menú de tres platos con un cuchillo, una sartén y un fuego. Se puede. Pero si cocinas todos los días para 50 comensales, quieres una cocina equipada: fogones con varios fuegos, horno con termostato, nevera con alarmas, abrelatas, termómetro de cocción, campana extractora. No es que el cuchillo deje de servir, es que el resto de herramientas te hacen más rápido, más seguro y te dejan concentrarte en lo importante: la receta. Un IDE es la cocina equipada del programador.

Un IDE (Integrated Development Environment) es un programa que integra, en una sola ventana, todo lo que un programador necesita para escribir código: editor con resaltado de sintaxis, autocompletado inteligente, compilador, depurador, gestor de proyectos, control de versiones, refactorización automática, inspección de errores en tiempo real, navegación entre archivos, integración con pruebas... Podrías programar con el bloc de notas y compilar a mano desde la consola, y de hecho lo harás alguna vez para entender qué pasa por debajo. Pero el día a día profesional se hace con IDE, porque multiplican la productividad.

Java tiene un ecosistema de IDEs maduro y competitivo. Los más usados son IntelliJ IDEA, Eclipse, NetBeans y VSCode. En este ciclo usaremos IntelliJ IDEA Community Edition porque es el más extendido en la industria, el que más crece en encuestas de desarrolladores, y el que mejor soporta las características modernas de Java (records, pattern matching, unnamed classes...). Además, su versión Community es gratuita y más que suficiente para todo el ciclo.

IDE	Licencia	Puntos fuertes	Puntos débiles	¿Lo usamos?
IntelliJ IDEA Community	Gratuito (Apache 2.0)	Mejor autocompletado, refactorizado potente, soporte Java 25	Algo pesado en RAM (~2 GB)	Sí, en todo el ciclo
Eclipse	Gratuito (EPL)	Muy ligero, plugins para todo	UI anticuada, autocompletado menos fino	No
Apache NetBeans	Gratuito (Apache 2.0)	Soporte Maven nativo históricamente	Comunidad más pequeña, menos oferta	No
Visual Studio Code	Gratuito (MIT)	Ligero, poliglota	Requiere configurar extensiones Java	IDE alternativo moderno y ligero

Antes de seguir, una aclaración importante: IntelliJ IDEA Community no incluye soporte para JavaFX ni para bases de datos avanzadas en la instalación base. En UD5 y UD9, cuando usemos JavaFX y JDBC, verás que las versiones "Ultimate" o plugins específicos lo facilitan; nosotros lo resolveremos con Maven y configuración manual para no depender de licencias de pago. Por ahora, con la Community vamos sobrados.

---

2.2 Instalar JDK 25 e IntelliJ IDEA Community

Paso 1: instalar el JDK 25 (Adoptium Temurin 25)

Hay muchas distribuciones de OpenJDK: Oracle, Amazon Corretto, Azul Zulu, Eclipse Temurin... En este ciclo usaremos Adoptium Temurin 25, la distribución mantenida por la Eclipse Foundation y referencia de facto en la industria. Es 100% OpenJDK, gratuita, y con binarios firmados para Windows, macOS y Linux.

1. Abre tu navegador en https://adoptium.net/temurin/releases/.
2. Selecciona Temurin 25 LTS, tu sistema operativo y tu arquitectura (x64 en la mayoría de casos; arm64 en Mac con Apple Silicon).
3. Descarga el instalador .msi (Windows), .pkg (macOS) o .tar.gz (Linux).
4. Ejecuta el instalador. En Windows, marca la casilla "Set JAVA_HOME variable" y "Add to PATH": te ahorrará configuración manual.
5. Tras instalar, abre una terminal nueva y verifica con:

$ java -version
openjdk version "25.0.4" 2026-07-21 LTS
OpenJDK Runtime Environment Temurin-25.0.4+7 (build 25.0.4+7-LTS)
OpenJDK 64-Bit Server VM Temurin-25.0.4+7 (build 25.0.4+7-LTS, mixed mode, sharing)

Si ves algo parecido a eso, enhorabuena: ya tienes Java 25 instalado y la consola lo encuentra. Si te aparece "java: command not found" o "java no se reconoce como un comando interno", es que la variable PATH no se configuró bien. Lo arreglas repitiendo el paso 4 o editando PATH a mano (lo veremos si te pasa en clase).

Cuidado

Cierra y vuelve a abrir la terminal después de instalar el JDK. Las variables de entorno solo se recargan en sesiones nuevas. Es el error más común: "lo he instalado, pero no me va".

Paso 2: instalar IntelliJ IDEA Community

1. Abre https://www.jetbrains.com/idea/download/.
2. Descarga el instalador para tu sistema operativo.
3. Ejecuta el instalador con las opciones por defecto. En Windows, marca "Add launchers dir to PATH" y "Add 'Open Folder as Project'".

1. La primera vez que abras IntelliJ puede pedirte si quieres importar configuración de una versión anterior: di "Do not import settings".
2. Te aparecerá la pantalla de bienvenida con opciones para crear proyecto nuevo, abrir proyecto existente o tirar de control de versiones.

---

2.3 Crear un proyecto Maven desde cero

Vamos a crear tu primer proyecto Maven. Maven es, sin entrar todavía en detalles, la herramienta que define la estructura de carpetas de tu proyecto, gestiona las dependencias (librerías externas como Jackson, JavaFX o JUnit) y ejecuta tareas como compilar, pasar pruebas o empaquetar. Lo verás con calma en la Sección 2.4.

Asistente de nuevo proyecto en IntelliJ

1. En la pantalla de bienvenida, pulsa New Project.
2. En el panel izquierdo selecciona Maven Archetype (o simplemente Maven en versiones recientes).
3. Rellena los campos:
   • Name: primerProyecto
   • Location: donde quieras guardar tus proyectos (recomendado: una carpeta ~/dam/programacion/).
   • JDK: selecciona 25 (Temurin) en el desplegable.
   • Catalog: Internal.
   • Archetype: selecciona org.apache.maven.archetypes:maven-archetype-quickstart (un esqueleto básico de proyecto Java).

4. En Advanced Settings rellena:

   • GroupId: jams.programacion.ud1
   • ArtifactId: primerProyecto
   • Version: 1.0-SNAPSHOT (la convención Maven para "versión en desarrollo").

5. Pulsa Create. IntelliJ generará la estructura de carpetas, descargará las dependencias iniciales de Maven y abrirá el proyecto.

Tras unos segundos de trabajo (la primera vez Maven descarga bastante del repositorio central; ten paciencia), verás en el panel izquierdo el árbol del proyecto, que debería parecerse a esto:

flowchart TD
    Root["primerProyecto/"] --> Pom["pom.xml<br/>(ficha técnica del proyecto)"]
    Root --> Src["src/<br/>(código fuente)"]
    Root --> Target["target/<br/>(generado al compilar)"]

    Src --> Main["main/"]
    Src --> Test["test/<br/>(pruebas unitarias)"]

    Main --> JavaM["java/<br/>(tu código .java)"]
    Main --> Res["resources/<br/>(config, imágenes, .properties)"]

    JavaM --> Pkg["jams/programacion/ud1/<br/>(paquete)"]
    Pkg --> MainJava["App.java"]

    Test --> JavaT["java/"]
    JavaT --> PkgT["jams/programacion/ud1/<br/>(paquete)"]
    PkgT --> TestJava["AppTest.java"]

    Target --> Classes["classes/<br/>(.class compilados)"]

    style Root fill:#1565c0,color:#fff,stroke:#0d47a1
    style Pom fill:#e3f2fd,stroke:#1565c0,color:#000
    style Src fill:#e8f5e9,stroke:#2e7d32,color:#000
    style Target fill:#fff3e0,stroke:#e65100,color:#000
    style Main fill:#e8f5e9,stroke:#2e7d32,color:#000
    style Test fill:#f3e5f5,stroke:#6a1b9a,color:#000
    style Pkg fill:#e3f2fd,stroke:#1565c0,color:#000
    style PkgT fill:#e3f2fd,stroke:#1565c0,color:#000
    style MainJava fill:#fffde7,stroke:#f57f17,color:#000
    style TestJava fill:#fffde7,stroke:#f57f17,color:#000

Diagrama 2.1 — Estructura estándar de un proyecto Maven en Java.

Anatomía de la estructura Maven

Ruta	Para qué sirve	¿Tocas?
pom.xml	Ficha técnica del proyecto: dependencias, versión de Java, plugins	Sí, mucho
src/main/java/	Tu código fuente Java (.java)	Sí, todo
src/main/resources/	Ficheros no código: .properties, .xml, imágenes, etc.	A veces
src/test/java/	Pruebas unitarias con JUnit	Sí, desde UD3
target/	Generado al compilar: .class, .jar, informes...	Nunca (se borra y regenera)
.idea/	Configuración interna de IntelliJ (no se sube a git)	No directamente

El paquete (directorio) que ves dentro de src/main/java/ sigue la convención jams.programacion.ud1, que es exactamente lo que pusiste como GroupId. A lo largo del módulo, cada unidad didáctica tendrá su propio paquete (jams.programacion.ud1, jams.programacion.ud2, ...). Esto permitirá tener todos los ejercicios del curso organizados en un único proyecto Maven sin que se pisen entre sí.

Analogía

Imagínate la carpeta del proyecto como la cocina de un restaurante. pom.xml es la lista de proveedores y recetas estándar que cuelga en la pared: define qué ingredientes tienes disponibles (dependencias) y cómo se prepara cada plato (plugins). src/main/java/ es la zona de cocinado, donde tú, el chef, preparas los platos. src/main/resources/ es la despensa de ingredientes no perecederos: fotos de presentación, fichas de alérgenos, manual del chef. src/test/java/ es la mesa de catas, donde pruebas cada plato antes de servirlo. Y target/ es el cubos de basura y bandejas de salida: lo que se genera al cocinar, ya sea para tirar o para servir.

---

2.4 El pom.xml explicado

El pom.xml es el corazón de un proyecto Maven. POM significa Project Object Model: es un fichero XML que describe tu proyecto para Maven. Sin ese fichero, Maven no sabe qué hacer. Con él, Maven es capaz de compilar, descargar dependencias, ejecutar pruebas, empaquetar y mucho más. Vamos a ver uno mínimo y a explicar cada parte.

El fichero generado será algo parecido a esto:

<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>jams.programacion.ud1</groupId>
  <artifactId>primerProyecto</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>primerProyecto</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

Y una versión más avanzada y actual quedaría así:

<?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>

    <!-- Coordenadas del proyecto (su "DNI") -->
    <groupId>jams.programacion.ud1</groupId>
    <artifactId>primerProyecto</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <!-- Metadatos -->
    <name>UD1 - Fundamentos de Programacion</name>
    <description>Practicas de la Unidad 1 del modulo de Programación (DAM)</description>

    <!-- Propiedades: version de Java y codificación -->
    <properties>
        <maven.compiler.release>25</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <!-- Dependencias: librerias externas que el proyecto necesita -->
    <dependencies>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.11.0</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <!-- Plugins: tareas adicionales para Maven -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.4.1</version>
                <configuration>
                    <mainClass>jams.programacion.ud1.App</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Coordenadas Maven: el DNI de tu proyecto

Las tres etiquetas groupId, artifactId y version forman las coordenadas que identifican unánimemente a tu proyecto en el ecosistema Maven. Sirven para que cualquier otro proyecto del mundo pueda referenciar el tuyo como dependencia. Por eso conviene elegirlas bien desde el principio.

Etiqueta	Qué es	Convención	Ejemplo
groupId	Identifica a la organización o autor	Dominio invertido	jams.programacion.ud1
artifactId	Identifica al proyecto concreto	minúsculas, sin guiones	primerProyecto
version	Versión del proyecto	X.Y.Z-SNAPSHOT para desarrollo, X.Y.Z para release	1.0-SNAPSHOT
packaging	Tipo de artefacto a generar	jar (librería/app), war (web)	jar

La convención de dominio invertido es importante: si tu dominio fuera ies.es, tu groupId podría ser es.ies.dam. Para proyectos personales, basta con usar tus iniciales o un identificador corto. Lo importante es que sea único y estable en el tiempo.

Propiedades: versión de Java y codificación

Dentro de <properties> configuramos dos cosas críticas: la versión de Java que usará el compilador y la codificación de los ficheros. La línea <maven.compiler.release>25</maven.compiler.release> es la que le dice a Maven: "compila este proyecto con Java 25". Si en el futuro quieres volver a Java 17 (por ejemplo, para un proyecto legacy), basta con cambiar ese 25 por 17 y recompilar. La codificación UTF-8 garantiza que las tildes y la ñ funcionen en cualquier sistema operativo: si no la pones, en Windows puede que veas símbolos raros.

Cuidado

No uses <source> y <target> por separado; son antiguos. La forma moderna desde Java 9 es <maven.compiler.release>, que fija a la vez la versión de origen, destino y API. Ahorra problemas.

Dependencias: el repositorio central de Maven

Una dependencia es una librería externa que tu proyecto necesita. Maven las descarga automáticamente de Maven Central (https://repo1.maven.org/maven2/), un repositorio público con millones de librerías. Cuando añades una <dependency> al pom.xml y guardas, IntelliJ detecta el cambio y Maven se encarga de bajar el .jar correspondiente a tu repositorio local (~/.m2/repository/ en tu carpeta de usuario). A partir de ahí, cualquier compilación o ejecución usa esa copia local.

Analogía

Maven Central es como Amazon para librerías Java. Tú, desde tu pom.xml (la lista de la compra), pides "una unidad de JUnit 5.11.0, por favor". Maven la busca en su almacén central, la descarga a tu carpeta ~/.m2/ (tu despensa particular) y a partir de ahí la tienes disponible siempre que la necesites, sin volver a pedirla. Si el lunes siguiente pides JUnit otra vez para otro proyecto, Maven no vuelve a Amazon: usa la copia que ya está en tu despensa.

La etiqueta <scope> indica cuándo se necesita la dependencia: test significa que solo se usa para las pruebas (no se incluye en el .jar final).

Plugins: tareas adicionales

Los plugins extienden lo que Maven sabe hacer. Maven viene de fábrica con un ciclo de vida básico (compilar, testear, empaquetar...), pero si necesitas algo especial (ejecutar la clase main, generar Javadoc, empaquetar como .exe, etc.), necesitas un plugin. En el pom.xml de arriba hemos incluido exec-maven-plugin, que permite ejecutar la clase jams.programacion.ud1.App con mvn exec:java. Lo usarás en la siguiente sección.

---

2.5 Compilar y ejecutar: mvn compile, mvn exec:java

Vamos a escribir tu primer programa Java 25 y a ejecutarlo tanto desde IntelliJ como desde la consola con Maven. Crea el fichero src/main/java/jams/programacion/ud1/App.java con este contenido:

package jams.programacion.ud1;

/**
 * Primer programa del ciclo.
 * @author DAM 26-27
 */
public class App {

    public static void main(String[] args) {
        String nombre = "mundo";
        System.out.println("Hola, " + nombre + "!");
        System.out.println("Estoy en Java " + Runtime.version().feature());
    }
}

No te preocupes ahora por entender cada palabra: eso es tarea de la Sección 3. Lo importante es que veas tres cosas. Primera, el fichero se llama App.java y la clase se llama App: en Java, el nombre del fichero debe coincidir con el nombre de la clase pública que contiene. Segunda, el paquete jams.programacion.ud1 declarado en la primera línea coincide exactamente con la ruta de carpetas donde está el fichero (src/main/java/jams/programacion/ud1/). Tercera, el método main es la puerta de entrada que busca la JVM cuando ejecutas el programa.

Pista

Java 25 permite una sintaxis moderna más compacta (void main() { ... } sin public class ni static) gracias a las clases declaradas implícitamente (implicitly declared classes) y método main de instancia (instance main methods) del JEP 512. La verás en la Sección 3. Aquí usamos la forma clásica porque es la que mejor se integra con Maven y la que encontrarás en cualquier proyecto normal. Ambas formas son válidas y producen el mismo resultado.

/**
 * Primer programa del ciclo.
 *
 * @author DAM 26-27
 */

void main(String[] args) {
    String nombre = "mundo";
    IO.println("Hola, " + nombre + "!");
    IO.println("Estoy en Java " + Runtime.version().feature());
}

Ejecutar desde IntelliJ

Lo más rápido: con el fichero App.java abierto, pulsa Shift+F10 (o el botón verde Play de la barra superior). IntelliJ compila con Maven por debajo, lanza la JVM y te muestra la salida en la ventana Run de abajo:

Hola, mundo!
Estoy en Java 25

Process finished with exit code 0

Si ves eso, ya tienes tu primer programa Java funcionando. Ese "exit code 0" es la forma que tiene la consola de decir "todo fue bien"; cualquier código distinto de 0 significa error.

Compilar y ejecutar desde la consola con Maven

Para entender qué hace IntelliJ por debajo, vamos a repetirlo a mano desde la terminal. Hay que instalar Maven desde la página oficial, ya que el IDE usa una versión de maven interna. Abre la terminal integrada de IntelliJ (abajo, pestaña Terminal, o Alt+F12) y ejecuta:

$ mvn -q compile
[INFO] Compiling 1 source file with javac
[INFO] BUILD SUCCESS

Maven ha compilado tu .java con el compilador javac y ha dejado el .class en target/classes/jams/programacion/ud1/App.class. Si miras dentro de target/, verás la estructura espejada. Ahora ejecútalo con:

$ mvn -q exec:java
Hola, mundo!
Estoy en Java 25

mvn exec:java es la orden que le dice a Maven: "invoca el plugin exec y ejecuta la clase main que configuramos en el pom.xml". Maven se encarga de montar el classpath correcto (buscar el .class en target/classes más todas las dependencias) y lanzar la JVM.

flowchart TD
    A["App.java<br/>(escribes en IntelliJ)"] -->|guardar| B["IntelliJ detecta<br/>el cambio"]
    B -->|Shift+F10| C["mvn compile<br/>(javac bajo el capó)"]
    C --> D["target/classes/<br/>App.class"]
    D --> E["java -cp target/classes<br/>App<br/>(arranca la JVM)"]
    D --> E["java -cp target/classes<br/>App<br/>(arranca la JVM)"]
    E --> F["Consola:<br/>Hola, mundo"]

    G["pom.xml<br/>dependencias"] -.->|gestiona| C
    H["~/.m2/<br/>repositorio local"] -.->|proporciona .jar| C

    style A fill:#e3f2fd,stroke:#1565c0,color:#000
    style B fill:#fff8e1,stroke:#f57f17,color:#000
    style C fill:#f3e5f5,stroke:#6a1b9a,color:#000
    style D fill:#f3e5f5,stroke:#6a1b9a,color:#000
    style E fill:#e8f5e9,stroke:#2e7d32,color:#000
    style F fill:#e0f2f1,stroke:#00695c,color:#000
    style G fill:#e3f2fd,stroke:#1565c0,color:#000
    style H fill:#fff3e0,stroke:#e65100,color:#000

Diagrama 2.3 — Flujo completo: editar el .java, compilar con Maven, ejecutar con la JVM.

El ciclo de vida de Maven

IntelliJ nos proporciona todo un panel para usar el comando Maven en nuestro proyecto, lo encontramos en la parte derecha del IDE.

Maven tiene un ciclo de vida predefinido con fases ordenadas. Cuando ejecutas mvn compile, ejecutas esa fase y todas las anteriores. Cuando ejecutas mvn package, ejecutas compile + test + package. Conocer las fases te ahorra sorpresas:

flowchart LR
    V["validate<br/>¿está bien<br/>el proyecto?"] --> C["compile<br/>javac"]
    C --> T["test<br/>JUnit"]
    T --> P["package<br/>.jar / .war"]
    P --> I["install<br/>al repo local<br/>~/.m2"]
    I --> D["deploy<br/>al repo remoto<br/>(Nexus/Artifactory)"]

    style V fill:#fff3e0,stroke:#e65100,color:#000
    style C fill:#e3f2fd,stroke:#1565c0,color:#000
    style T fill:#f3e5f5,stroke:#6a1b9a,color:#000
    style P fill:#e8f5e9,stroke:#2e7d32,color:#000
    style I fill:#fff8e1,stroke:#f57f17,color:#000
    style D fill:#ffebee,stroke:#c62828,color:#000

Diagrama 2.2 — Ciclo de vida estándar de Maven (fases principales).

Fase	Qué hace	Comando	Cuándo la usas
validate	Valida que el pom.xml es correcto y la info es completa	mvn validate	Casi nunca manualmente
compile	Compila el código fuente a .class	mvn compile	Para ver si compila
test	Ejecuta las pruebas unitarias con JUnit	mvn test	Antes de cada commit
package	Empaqueta los .class en .jar (o .war)	mvn package	Cuando vas a distribuir
verify	Ejecuta pruebas de integración y comprobaciones	mvn verify	En integración continua
install	Copia el .jar a tu repositorio local ~/.m2/	mvn install	Cuando otro proyecto lo necesita
deploy	Sube el .jar a un repositorio remoto (Nexus, Artifactory)	mvn deploy	Solo en empresa

Pista

En el día a día usarás sobre todo mvn compile, mvn test y mvn exec:java. Si quieres hacer varias cosas a la vez puedes encadenarlas: mvn clean compile exec:java limpia, recompila y ejecuta. El clean borra target/ antes, útil cuando algo va raro y quieres empezar de cero.

---

2.6 Atajos de teclado imprescindibles en IntelliJ

Analogía

Aprender los atajos de IntelliJ es como aprender a tocar el piano sin mirar las teclas. Al principio vas lento, miras, te equivocas. A los tres meses lo haces sin pensar y tu velocidad de programación se multiplica por tres. Los programadores que no usan atajos parecen mecánicos; los que los dominan parecen músicos. La diferencia la notarás tú el primero.

Hay decenas de atajos, pero con ocho o diez bien aprendidos tienes el 80% del beneficio. Memoriza estos antes de seguir:

Atajo (Win/Linux)	Atajo (macOS)	Qué hace
Shift+F10	Ctrl+R	Ejecutar la clase actual (Run)
Shift+F9	Ctrl+D	Depurar la clase actual (Debug)
Alt+Enter	Option+Enter	Solución mágica: arregla el error de debajo del cursor, sugiere refactor, importa la clase...
Ctrl+Space	Ctrl+Space	Autocompletado básico (métodos, variables, clases)
Ctrl+Shift+Space	Ctrl+Shift+Space	Autocompletado inteligente (solo lo que encaja por tipo)
Ctrl+B / Ctrl+Click	Cmd+B	Ir a la definición del símbolo debajo del cursor
Alt+Insert	Cmd+N	Generar código: constructor, getter, setter, equals, toString...
Ctrl+Alt+L	Cmd+Option+L	Formatear el código según el estilo del proyecto
Ctrl+Alt+O	Ctrl+Option+O	Optimizar imports (quita los que no se usan)
Ctrl+Z / Ctrl+Shift+Z	Cmd+Z / Cmd+Shift+Z	Deshacer / Rehacer
Shift dos veces	Shift dos veces	Search Everywhere: busca cualquier cosa
Ctrl+N	Cmd+O	Buscar una clase por nombre
Ctrl+Shift+T	Cmd+Shift+T	Crear o ir al test de la clase actual
F8 (en depuración)	F8	Step over: ejecuta la línea sin entrar en métodos
F7 (en depuración)	F7	Step into: entra dentro del método

Las zonas de la pantalla de IntelliJ

Para que los atajos tengan sentido, conviene que identifiques las zonas principales de la pantalla de IntelliJ. El siguiente diagrama las resume:

flowchart TD
    subgraph TOP["Barra superior - Run toolbar"]
        R["Run  Shift+F10"]
        D["Debug  Shift+F9"]
    end

    subgraph LEFT["Project Tool Window"]
        P["Árbol de<br/>archivos y paquetes"]
    end

    subgraph CENTER["Editor"]
        E["Tu código .java<br/>con resaltado y autocompletado"]
    end

    subgraph BOTTOM["Tool windows inferiores"]
        T1["Terminal"]
        T2["Build<br/>(salida de Maven)"]
        T3["Problems<br/>(errores)"]
    end

    subgraph RIGHT["Tool windows derechas"]
        M["Maven<br/>(tareas y ciclo de vida)"]
    end

    TOP --- LEFT
    LEFT --- CENTER
    CENTER --- BOTTOM
    BOTTOM --- RIGHT

    style TOP fill:#1565c0,color:#fff,stroke:#0d47a1
    style LEFT fill:#e8f5e9,stroke:#2e7d32,color:#000
    style CENTER fill:#fff8e1,stroke:#f57f17,color:#000
    style BOTTOM fill:#f3e5f5,stroke:#6a1b9a,color:#000
    style RIGHT fill:#fff3e0,stroke:#e65100,color:#000

Diagrama 2.4 — Zonas principales de la pantalla de IntelliJ IDEA.

Zona	Dónde está	Para qué sirve
Run toolbar	Arriba derecha	Botones de Run (Shift+F10), Debug (Shift+F9), configuración de ejecución
Project tool window	Izquierda	Árbol de archivos del proyecto. Se oculta con Alt+1
Editor	Centro	Donde escribes el código. Pestañas para cada fichero abierto
Tool windows inferiores	Abajo	Terminal, Build (salida Maven), Problems, Run, Debug...
Tool windows derechas	Derecha	Maven (tareas y ciclo de vida), Database, Git...

Pista

Si se te cierra una tool window por accidente (Project, Terminal...), reábrela con el atajo Alt+número: Alt+1 para Project, Alt+2 para Favorites, etc. O desde el menú View → Tool Windows.

---

2.7 jshell: tu bloc de notas para probar Java

Antes de cerrar la sección, una herramienta que usarás más de lo que crees: jshell. Es la consola interactiva de Java (un REPL, Read-Eval-Print Loop) que viene con el JDK desde Java 9. Te permite escribir expresiones Java y ver el resultado al instante, sin tener que crear un proyecto ni un fichero. Es ideal para probar cómo funciona un método, ver qué devuelve una operación o experimentar con una API nueva.

Abre una terminal y escribe jshell. Verás el prompt jshell>:

$ jshell
|  Welcome to JShell -- Version 25
|  For an introduction type: /help intro

jshell> var nombre = "mundo"
nombre ==> "mundo"

jshell> System.out.println("Hola, " + nombre)
Hola, mundo

jshell> 2 + 3 * 4
$3 ==> 14

jshell> /exit
|  Goodbye

Todo lo que pruebes en jshell se olvida al cerrar la sesión (a menos que uses /save fichero.txt). Es perfecto para resolver dudas tipo "¿qué devuelve Integer.parseInt("42")?" en dos segundos sin montar un proyecto entero. A lo largo del curso lo usaremos para experimentar con tipos, operadores y métodos del API.

---

Resumen de la sección 2

Antes de pasar a la siguiente sección, asegúrate de que controlas estos puntos:

1. Un IDE integra editor, compilador, depurador y gestión de proyectos en una sola herramienta. Usaremos IntelliJ IDEA Community por su mejor soporte de Java moderno y su posición dominante en el mercado laboral.
2. Has instalado JDK 25 (Adoptium Temurin) y IntelliJ IDEA Community, y verificado con java -version que la consola reconoce Java.
3. Has creado tu primer proyecto Maven con estructura estándar: pom.xml, src/main/java/, src/main/resources/, src/test/java/, target/.
4. El pom.xml define las coordenadas del proyecto (groupId, artifactId, version), la versión de Java (<maven.compiler.release>25</maven.compiler.release>), las dependencias y los plugins.
5. Para compilar usas mvn compile, para ejecutar mvn exec:java (gracias al plugin exec-maven-plugin configurado en el pom). Maven descarga las dependencias automáticamente a tu ~/.m2/.
6. El ciclo de vida de Maven ordena tareas: validate → compile → test → package → install → deploy. Cada fase ejecuta las anteriores.
7. Has memorizado los atajos esenciales de IntelliJ: Shift+F10 (Run), Alt+Enter (solución mágica), Ctrl+Space (autocompletar), Shift+Shift (buscar todo).
8. jshell es tu bloc de notas interactivo para probar expresiones Java al instante.

---

Ejercicio

Crea un nuevo proyecto usando la plantilla Java en el lado izquierdo, seleccionando Maven y compara los archivos creados con los creados con el arquetipo quickstart.