Saltar a contenido

2. IntelliJ IDEA y Maven: el entorno de trabajo

2.1 Instalación de JDK 25 e IntelliJ IDEA Community

Antes de escribir una sola línea de código necesitamos montar el taller. Dos piezas:

  1. JDK 25 (Adoptium Temurin): descárgalo desde adoptium.net, eligiendo la versión 25 (LTS) correspondiente a tu sistema operativo. El instalador se encarga de todo; en Windows, marca la opción de añadirlo al PATH si el instalador lo ofrece.
  2. IntelliJ IDEA Community Edition: es un IDE (Integrated Development Environment, entorno de desarrollo integrado), es decir, un editor de texto con superpoderes: autocompletado inteligente, detección de errores en tiempo real, refactorización automática, depurador visual y gestión integrada de proyectos Maven. La edición Community es gratuita y de código abierto, y es más que suficiente para todo lo que haremos en el módulo.

🛠️ ¿Por qué un IDE y no simplemente el Bloc de Notas? Podrías escribir Java en cualquier editor de texto plano y compilarlo a mano por terminal. Pero sería como intentar montar un mueble de IKEA sin las herramientas que trae la caja: técnicamente posible, pero te vas a dejar la salud. El IDE te avisa de errores antes de ejecutar, te sugiere el código mientras escribes y te ahorra cientos de comandos de terminal repetitivos.

2.2 Crear un proyecto Maven desde cero

Maven es una herramienta de gestión de proyectos y dependencias. Su trabajo es doble:

  • Define una estructura de carpetas estándar para que cualquier programador Java del mundo sepa dónde encontrar qué, sin sorpresas.
  • Gestiona automáticamente las librerías externas que tu proyecto necesita (más adelante: JUnit, Jackson, JavaFX...), descargándolas de un repositorio central sin que tengas que ir a buscarlas a mano por internet.

📦 Analogía: Maven es como el encargado de almacén de una fábrica. Tú le dices en una lista de la compra (pom.xml) qué piezas necesitas y de qué versión exacta, y él se encarga de traerlas del almacén central (Maven Central) y colocarlas donde tocan, sin que tú tengas que ir a buscarlas.

Al crear un nuevo proyecto Maven en IntelliJ (File → New → Project → Maven), se genera automáticamente esta estructura de carpetas:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
ud1-fundamentos/
├── pom.xml                                    ← el "contrato" del proyecto
├── src/
│   ├── main/
│   │   └── java/
│   │       └── dam/
│   │           └── programacion/
│   │               └── ud1/
│   │                   └── Main.java          ← aquí va TU código
│   └── test/
│       └── java/
│           └── dam/
│               └── programacion/
│                   └── ud1/                   ← aquí irán los tests JUnit (más adelante)
└── target/                                    ← se genera SOLO al compilar, nunca se toca a mano

Fíjate en un detalle importante: la ruta de carpetas dentro de src/main/java/ reproduce exactamente el nombre del paquete separado por barras. Si tu clase declara package dam.programacion.ud1;, el fichero .java tiene que vivir en src/main/java/dam/programacion/ud1/. No es una sugerencia de estilo: si no coincide, el proyecto no compila correctamente.

A lo largo de este curso, cada unidad didáctica usará su propio subpaquete siguiendo el patrón dam.programacion.udN (donde N es el número de unidad, del 1 al 9), para que el código de cada tema quede perfectamente organizado y sea fácil de localizar.

2.3 El pom.xml explicado

El pom.xml (Project Object Model) es el fichero de configuración central de Maven. Es un documento XML que describe qué es tu proyecto y qué necesita para compilar y ejecutarse.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
<?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">

    <!-- Versión del formato del propio pom.xml, siempre 4.0.0 -->
    <modelVersion>4.0.0</modelVersion>

    <!-- ============================================================
         IDENTIFICACIÓN ÚNICA DEL PROYECTO ("las coordenadas Maven")
         Cualquier proyecto Maven del mundo se identifica de forma
         única mediante la combinación groupId + artifactId + version
         ============================================================ -->

    <!-- groupId: identifica a "quién" pertenece el proyecto.
         Usaremos siempre dam.programacion en todo el módulo -->
    <groupId>dam.programacion</groupId>

    <!-- artifactId: el nombre concreto de ESTE proyecto/unidad -->
    <artifactId>ud1-fundamentos</artifactId>

    <!-- version: la versión de nuestro propio proyecto.
         SNAPSHOT indica que es una versión "en desarrollo" -->
    <version>1.0-SNAPSHOT</version>

    <!-- empaquetado por defecto: un .jar ejecutable -->
    <packaging>jar</packaging>

    <!-- ============================================================
         PROPIEDADES: variables reutilizables en todo el pom.xml
         ============================================================ -->
    <properties>
        <!-- Le decimos al compilador de Maven que use Java 25 -->
        <maven.compiler.source>25</maven.compiler.source>
        <maven.compiler.target>25</maven.compiler.target>

        <!-- Evita problemas con tildes, ñ, etc. en el código fuente -->
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <!-- ============================================================
         DEPENDENCIAS: librerías externas que necesita el proyecto.
         En UD1 no necesitamos ninguna todavía: solo usamos el JDK
         estándar. Aquí es donde, a partir de UD2, iremos añadiendo
         JUnit, y más adelante Jackson, JavaFX, JPA, sqlite-jdbc...
         ============================================================ -->
    <dependencies>
        <!-- (vacío por ahora, se irá llenando unidad a unidad) -->
    </dependencies>

    <!-- ============================================================
         BUILD: configuración de cómo se compila y ejecuta el proyecto
         ============================================================ -->
    <build>
        <plugins>
            <!-- Plugin para poder ejecutar "mvn exec:java" desde terminal -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.5.0</version>
                <configuration>
                    <!-- Indica cuál es la clase con el método main -->
                    <mainClass>dam.programacion.ud1.Main</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>
Etiqueta Significado
groupId Quién "es dueño" del proyecto (organización, en nuestro caso dam.programacion)
artifactId Nombre concreto de este proyecto/módulo
version Versión del propio proyecto (no de Java). SNAPSHOT = en desarrollo
<maven.compiler.source/target> Versión de Java con la que se compila y para la que se genera el bytecode
<dependencies> Lista de librerías externas necesarias (vacía en UD1, se llenará en unidades futuras)
<build><plugins> Herramientas adicionales que amplían lo que Maven puede hacer (aquí, ejecutar la app)

🔮 Mirando al roadmap: este mismo pom.xml que hoy parece casi vacío es el que iremos ampliando durante todo el curso. En UD2 le añadiremos JUnit 5 para probar código; en UD5, Jackson y JavaFX; en UD8, JPA y ObjectDB; en UD9, el driver SQLite. Aprender bien su estructura ahora te ahorra muchos quebraderos de cabeza después.

2.4 Compilar y ejecutar con Maven

Maven organiza su trabajo en un ciclo de vida de fases encadenadas: cada fase ejecuta automáticamente todas las anteriores.

Comando Qué hace Analogía de cocina
mvn compile Traduce tu código .java a bytecode .class en la carpeta target/ Amasar y meter el pan al horno: lo preparas, pero aún no lo sirves
mvn exec:java Ejecuta la clase principal configurada en el pom.xml Sacar el pan del horno y servirlo en la mesa
mvn test Ejecuta las pruebas automáticas del proyecto (JUnit, lo veremos en UD2) Probar el plato antes de servirlo al cliente
mvn package Empaqueta el proyecto compilado en un .jar distribuible Envasar el pan al vacío para llevarlo a otro sitio
mvn clean Borra todo lo generado en target/ Limpiar la cocina antes de volver a cocinar desde cero

En el día a día casi nunca teclearás estos comandos a mano: usarás el botón ▶️ verde de IntelliJ, que internamente hace exactamente lo mismo (compilar + ejecutar). Pero es fundamental que entiendas qué ocurre "por debajo", porque en UD9 usaremos la terminal con más soltura y porque en el mundo profesional, estos mismos comandos se ejecutan de forma automatizada en servidores de integración continua.

2.5 Atajos de teclado imprescindibles en IntelliJ

Memorizar estos cinco atajos desde el primer día te va a ahorrar semanas de clics innecesarios a lo largo del curso.

Atajo (Win/Linux) Atajo (macOS) Acción Cuándo lo usarás
Shift + F10 Ctrl + R Ejecutar el programa Cada vez que quieras probar tu código
F8 F8 Step Over: avanzar una línea sin entrar en los métodos Al depurar (lo trabajaremos a fondo en UD3)
Alt + Enter ⌥ + Enter Mostrar soluciones rápidas (importar clases, corregir errores...) Cuando IntelliJ subraya algo en rojo o amarillo
Ctrl + Space ⌃ + Space Autocompletado de código Al escribir nombres de clases, métodos o variables
Ctrl + Alt + L ⌥ + ⌘ + L Reformatear el código automáticamente Para mantener una indentación limpia y profesional

💬 Consejo de profesor con chispa: Alt + Enter es, sin exagerar, el atajo que más veces vas a pulsar en tu vida como programador Java. Cuando algo se subraye en rojo, resiste el impulso de borrarlo todo por pánico: pulsa Alt + Enter y deja que IntelliJ te proponga la solución. El 80% de las veces acierta.

🧠 Autoevaluación exprés — Punto 2 (haz clic para ver las preguntas) 1. ¿Qué dos problemas resuelve Maven que no resolvería copiar y pegar carpetas a mano? 2. Si tu clase declara `package dam.programacion.ud1;`, ¿en qué ruta exacta debe estar guardado el fichero `.java` dentro de un proyecto Maven? 3. ¿Qué diferencia hay entre `mvn compile` y `mvn exec:java`? 4. ¿Para qué sirve la sección `` del `pom.xml`, aunque hoy la tengamos vacía? Respuestas orientativas: (1) estandariza la estructura de carpetas y gestiona automáticamente las librerías externas. (2) src/main/java/dam/programacion/ud1/. (3) compile solo traduce a bytecode; exec:java además ejecuta la clase principal. (4) Ahí se declaran las librerías externas que el proyecto necesitará (JUnit, Jackson, JavaFX...), y Maven las descarga automáticamente.