Módulo 01: Entorno de desarrollo

Objetivos del módulo

  • Instalar el JDK 25 en Windows, macOS o Linux
  • Configurar las variables de entorno JAVA_HOME y PATH y comprobar la instalación con java -version y javac -version
  • Escribir, compilar y ejecutar tu primer programa con un editor de texto y la terminal
  • Ejecutar un programa directamente desde el código fuente con java Hola.java
  • Entender palabra a palabra la estructura public class Hola { public static void main(String[] args) { ... } }
  • Conocer la forma compacta de Java 25 (void main() y IO.println)
  • Probar código al vuelo con JShell
  • Instalar y usar IntelliJ IDEA: crear un proyecto, ejecutar programas y configurar el IDE
  • Conocer VS Code con el Extension Pack for Java como alternativa, y saber que existen Eclipse y NetBeans
  • Leer e interpretar los mensajes de error del compilador
  • Organizar tus carpetas y ficheros siguiendo las convenciones de Java

1. ¿Qué necesitas para programar en Java?

En el módulo 00 viste que para crear programas en Java necesitas el JDK, que incluye el compilador javac y la máquina virtual java. Con eso ya podrías programar usando el Bloc de notas. Pero en la práctica también usarás un IDE (Integrated Development Environment, entorno de desarrollo integrado), un programa que reúne en una sola ventana el editor, el compilador, la ejecución y el depurador, y que te ayuda mientras escribes.

Herramienta Qué es ¿Es obligatoria? En este curso
JDK 25 Compilador, JVM, biblioteca estándar y herramientas Sí Eclipse Temurin 25 (u Oracle JDK 25)
Editor de texto + terminal La forma más básica de programar No, pero muy didáctica Primeros programas de este módulo
IDE Editor inteligente + compilación + ejecución + depuración No, pero imprescindible en la práctica IntelliJ IDEA (alternativa: VS Code)
JShell Consola interactiva para probar fragmentos de código No Para experimentar

💡 Consejo: Aunque el IDE lo hace todo por ti, merece la pena compilar y ejecutar a mano al menos los primeros programas. Así entenderás qué hace el IDE cuando pulsas el botón ▶ y sabrás resolver los problemas cuando algo falle (y en los exámenes prácticos a veces solo tendrás una terminal).

2. Instalar el JDK 25

Este curso usa Java 25, la versión LTS actual. Puedes instalar cualquier distribución (módulo 00, sección 10); aquí explicamos Eclipse Temurin, gratuita y de código abierto, y Oracle JDK. El proceso es casi idéntico con las demás.

⚠️ Importante: Instala el JDK (no el JRE) de la versión 25. Si en tu ordenador ya hay otro JDK (por ejemplo, el 17 o el 21 que instaló otra asignatura), no pasa nada: pueden convivir varios. Lo importante es que java y javac apunten al 25, y eso lo controlan JAVA_HOME y PATH.

2.1. Windows con Eclipse Temurin

  1. Entra en adoptium.net y ve a la sección de descargas de Temurin.
  2. Elige Sistema operativo: Windows; Arquitectura: x64 (o aarch64 si tu portátil tiene un procesador ARM, como los Snapdragon); Tipo de paquete: JDK; Versión: 25 - LTS.
  3. Descarga el instalador .msi y ejecútalo.
  4. En la pantalla Custom Setup, despliega la opción Set or override JAVA_HOME variable y elige Will be installed on local hard drive. Las opciones Add to PATH y Associate .jar ya vienen activadas.

Esquema del asistente de instalación de Eclipse Temurin: pantalla Custom Setup con la opción Set or override JAVA_HOME variable activada

Figura 1. Esquema de la pantalla Custom Setup del instalador de Temurin.

En la figura:

  • ① La opción Set or override JAVA_HOME variable aparece desactivada (con una ✕ roja). Haz clic en ella.
  • ② En el menú, elige Will be installed on local hard drive. Así el instalador crea la variable JAVA_HOME por ti.
  • ③ Pulsa Next y después Install. Windows te pedirá permiso de administrador.

La carpeta de instalación será parecida a C:\Program Files\Eclipse Adoptium\jdk-25.0.1.8-hotspot\ (los números finales dependen de la actualización que descargues).

💡 Consejo: Si te manejas con la terminal, en Windows 10/11 también puedes instalarlo con el gestor de paquetes winget. Busca el identificador exacto con winget search Temurin y luego instálalo con winget install EclipseAdoptium.Temurin.25.JDK.

2.2. Windows con Oracle JDK

  1. Entra en oracle.com/java/technologies/downloads, pestaña JDK 25, sistema Windows.
  2. Descarga el x64 Installer (.exe) o el x64 MSI Installer y ejecútalo con las opciones por defecto.
  3. Se instala en C:\Program Files\Java\jdk-25.

El instalador de Oracle añade al PATH una carpeta propia (C:\Program Files\Common Files\Oracle\Java\javapath) con accesos a java y javac, pero no crea JAVA_HOME. Créala a mano como se explica en la sección 2.3: muchas herramientas (Maven, Gradle, algunos IDE) la necesitan.

2.3. Configurar JAVA_HOME y PATH a mano en Windows

Hazlo si instalaste el JDK sin marcar la opción de JAVA_HOME, si usaste un .zip, o si javac no funciona en la terminal (sección 3).

📘 Concepto: Una variable de entorno es un dato con nombre que el sistema operativo pone a disposición de todos los programas. JAVA_HOME guarda la carpeta donde está instalado el JDK. PATH (en Windows aparece como Path) es la lista de carpetas donde el sistema busca los programas que escribes en la terminal. Si la carpeta bin del JDK no está en el PATH, al escribir javac el sistema no lo encuentra.

Paso 1. Abre la ventana de variables de entorno. Pulsa la tecla Windows, escribe variables de entorno y elige Editar las variables de entorno del sistema. Se abre Propiedades del sistema directamente en la pestaña Opciones avanzadas.

Esquema de la ventana Propiedades del sistema, pestaña Opciones avanzadas, con el botón Variables de entorno resaltado

Figura 2. Esquema de la ventana Propiedades del sistema de Windows 11.

  • ① Pulsa Variables de entorno…

Paso 2. Crea JAVA_HOME. La ventana tiene dos zonas: arriba, las variables de tu usuario; abajo, las del sistema (para todos los usuarios, requieren permisos de administrador). Trabaja en la de abajo si puedes; si no tienes permisos (ordenadores del centro), usa la de arriba: funciona igual para tu usuario.

Esquema de la ventana Variables de entorno con JAVA_HOME y Path en las variables del sistema

Figura 3. Esquema de la ventana Variables de entorno.

  • ① En Variables del sistema, pulsa Nueva…
  • ② Así quedará la variable JAVA_HOME una vez creada.
  • ③ La variable Path, que editarás en el paso 3.

En el diálogo Nueva variable del sistema (parte A de la figura 4):

  • ① Nombre de la variable: JAVA_HOME
  • ② Valor de la variable: la carpeta del JDK, sin \bin al final. Pulsa Examinar directorio… para elegirla sin errores de escritura (por ejemplo C:\Program Files\Eclipse Adoptium\jdk-25.0.1.8-hotspot o C:\Program Files\Java\jdk-25).

Paso 3. Añade %JAVA_HOME%\bin al Path. Selecciona Path en Variables del sistema y pulsa Editar… (parte B de la figura 4).

Esquema de los diálogos Nueva variable del sistema y Editar la variable de entorno con %JAVA_HOME%\bin añadido

Figura 4. Esquema de los diálogos para crear JAVA_HOME y editar Path.

  • ③ Pulsa Nuevo.
  • ④ Escribe %JAVA_HOME%\bin. Los símbolos %...% significan “el valor de la variable”, así que Windows lo traducirá a C:\Program Files\...\jdk-...\bin.
  • ⑤ Si tienes otro Java instalado más arriba en la lista (por ejemplo, C:\Program Files\Common Files\Oracle\Java\javapath de una instalación antigua), selecciona tu línea y pulsa Subir hasta que quede por encima: Windows usa la primera carpeta que contenga el programa.

Paso 4. Pulsa Aceptar en todas las ventanas y cierra y vuelve a abrir la terminal. Los cambios en las variables de entorno solo los ven las terminales que se abran después.

⚠️ Importante: No borres nada del Path que no sepas qué es: otros programas lo necesitan. Solo añade tu línea y, si hace falta, súbela.

2.4. macOS

  1. En adoptium.net, elige macOS, arquitectura aarch64 si tu Mac tiene un chip Apple (M1, M2, M3, M4…) o x64 si es un Mac con Intel, y descarga el .pkg.
  2. Ábrelo y sigue el asistente. El JDK se instala en /Library/Java/JavaVirtualMachines/temurin-25.jdk/.
  3. macOS ya encuentra java y javac sin tocar el PATH. Para definir JAVA_HOME, añade esta línea al final del fichero ~/.zshrc (la terminal de macOS usa zsh):
export JAVA_HOME=$(/usr/libexec/java_home -v 25)

Con Homebrew instalado, también puedes hacerlo con un solo comando:

brew install --cask temurin@25

Para ver todos los JDK instalados en el Mac:

/usr/libexec/java_home -V

2.5. Linux

Tienes varias opciones:

# Ubuntu / Debian (versiones recientes que incluyen el paquete)
sudo apt update
sudo apt install openjdk-25-jdk

# Fedora
sudo dnf install java-25-openjdk-devel

Si tu distribución aún no incluye el JDK 25, puedes añadir el repositorio oficial de Adoptium (paquete temurin-25-jdk; las instrucciones están en adoptium.net) o usar SDKMAN!, una herramienta que instala y cambia de versión de JDK con un comando:

sdk list java            # muestra las distribuciones y versiones disponibles
sdk install java 25.0.1-tem

(El identificador exacto, como 25.0.1-tem, lo ves en la lista de sdk list java.)

Si tienes varios JDK, en Debian y Ubuntu puedes elegir cuál se usa por defecto con:

sudo update-alternatives --config java
sudo update-alternatives --config javac

Y para definir JAVA_HOME, añade al final de ~/.bashrc (la ruta exacta depende de la distribución):

export JAVA_HOME=/usr/lib/jvm/java-25-openjdk-amd64
export PATH="$JAVA_HOME/bin:$PATH"

3. Comprobar la instalación

Abre una terminal nueva: en Windows, Terminal o PowerShell (tecla Windows y escribe “terminal”); en macOS, Terminal; en Linux, la que traiga tu escritorio. Escribe estos dos comandos:

java -version
javac -version

Con Eclipse Temurin 25 verás algo así (los números de la actualización pueden variar):

openjdk version "25.0.4.1" 2026-08-18 LTS
OpenJDK Runtime Environment Temurin-25.0.4.1+1 (build 25.0.4.1+1-LTS)
OpenJDK 64-Bit Server VM Temurin-25.0.4.1+1 (build 25.0.4.1+1-LTS, mixed mode, sharing)

javac 25.0.4.1

Fíjate en tres cosas: que pone 25, que pone LTS y que las dos versiones coinciden. Con Oracle JDK, la primera línea empieza por java version "25..." en lugar de openjdk version.

Otros comandos útiles para diagnosticar problemas:

Qué quieres saber Windows (PowerShell) Windows (cmd) macOS / Linux
Valor de JAVA_HOME $env:JAVA_HOME echo %JAVA_HOME% echo $JAVA_HOME
Qué java se está usando where.exe java where java which java
Qué javac se está usando where.exe javac where javac which javac

3.1. Problemas frecuentes

Si en Windows escribes javac -version y el sistema no lo encuentra, verás uno de estos mensajes reales:

En el símbolo del sistema (cmd):

"javac" no se reconoce como un comando interno o externo,
programa o archivo por lotes ejecutable.

En PowerShell:

javac : El término 'javac' no se reconoce como nombre de un cmdlet, función, archivo de script o programa ejecutable. Compruebe si escribió correctamente el nombre o, si incluyó una ruta de acceso, compruebe que dicha ruta es correcta e inténtelo de nuevo.
Síntoma Causa probable Solución
javac no se reconoce La carpeta bin del JDK no está en el Path Añade %JAVA_HOME%\bin (sección 2.3) y abre una terminal nueva
java funciona pero javac no Solo está en el Path un JRE o la carpeta javapath de una instalación antigua Comprueba con where.exe java y where.exe javac; pon %JAVA_HOME%\bin el primero
java -version muestra 17 o 21 Hay otro JDK antes en el Path Sube %JAVA_HOME%\bin en la lista del Path
java y javac muestran versiones distintas Mezcla de instalaciones Igual que el anterior. Si no lo corriges, verás UnsupportedClassVersionError (módulo 00)
echo %JAVA_HOME% muestra el texto %JAVA_HOME% La variable no existe Créala (sección 2.3)
Has cambiado las variables y no se nota La terminal estaba abierta antes del cambio Cierra y abre la terminal (o el IDE)

4. Tu primer programa con el Bloc de notas y la terminal

Vamos a escribir el programa más famoso de la historia de la programación: el que muestra “¡Hola, mundo!”.

4.1. Prepara una carpeta de trabajo

Crea una carpeta para tus programas sin espacios ni tildes en la ruta, por ejemplo C:\java\hola en Windows o ~/java/hola en macOS y Linux.

💡 Consejo: Evita guardar tus programas en carpetas sincronizadas con la nube (OneDrive, Google Drive) o con espacios y caracteres especiales en la ruta. Java funciona con ellas, pero algunas herramientas y scripts dan problemas difíciles de diagnosticar.

4.2. Escribe el código

Abre el Bloc de notas (en macOS, TextEdit en modo texto sin formato: menú Formato → Convertir en texto sin formato; en Linux, gedit, Kate o nano) y escribe exactamente esto, respetando mayúsculas y minúsculas:

public class Hola {
    public static void main(String[] args) {
        System.out.println("¡Hola, mundo!");
    }
}

Guárdalo con Archivo → Guardar como…:

  • Nombre: Hola.java (con H mayúscula, igual que el nombre de la clase).
  • Tipo: Todos los archivos (*.*). Si dejas Documentos de texto (*.txt), el Bloc de notas lo guardará como Hola.java.txt y no funcionará.
  • Codificación: UTF-8 (es la opción por defecto en Windows 11). Así las tildes y la ¡ se ven bien.

⚠️ Importante: Activa en el Explorador de Windows la opción Ver → Mostrar → Extensiones de nombre de archivo. Si no, Windows oculta las extensiones y no verás si tu fichero se llama Hola.java o Hola.java.txt.

4.3. Compila con javac

Abre la terminal y sitúate en la carpeta con cd:

cd C:\java\hola

Compila el programa:

javac Hola.java

Si todo va bien, no se muestra nada (en programación, “sin noticias, buenas noticias”). Pero en la carpeta ha aparecido un fichero nuevo, Hola.class, con el bytecode. Compruébalo con dir (en macOS y Linux, ls -l):

    Directorio: C:\java\hola

Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
-a----        04/10/2026     13:45            416 Hola.class
-a----        04/10/2026     13:23            119 Hola.java

4.4. Ejecuta con java 

java Hola

¡Hola, mundo!

¡Enhorabuena, acabas de ejecutar tu primer programa en Java!

⚠️ Importante: Al compilar se escribe el nombre del fichero con su extensión (javac Hola.java). Al ejecutar se escribe el nombre de la clase, sin extensión (java Hola). Si escribes java Hola.class, la JVM buscará una clase llamada literalmente Hola.class y fallará (lo verás en la sección 11).

Resumen del ciclo:

flowchart LR
    A["Hola.java<br/>(código fuente)"] -->|"javac Hola.java"| B["Hola.class<br/>(bytecode)"]
    B -->|"java Hola"| C["JVM"]
    C --> D["¡Hola, mundo!"]

Cada vez que modifiques el código fuente, tienes que volver a compilar antes de ejecutar. Si no, la JVM ejecutará el .class antiguo.

4.5. Lanzamiento directo: java Hola.java

Desde Java 11 puedes ejecutar un programa directamente desde el código fuente, sin el paso de javac:

java Hola.java

¡Hola, mundo!

La JVM compila el fichero en memoria y lo ejecuta, sin generar ningún .class. Es muy cómodo para programas pequeños de un solo fichero, como los de los primeros módulos. Desde Java 22, además, funciona con programas de varios ficheros en la misma carpeta: el lanzador compila automáticamente las demás clases que necesite.

Forma Comandos Genera .class Cuándo usarla
Clásica javac Hola.java y después java Hola Sí Siempre funciona; necesaria para distribuir programas
Lanzamiento directo java Hola.java No Programas pequeños y pruebas rápidas
IDE Botón ▶ Sí (en la carpeta out o target) El día a día

5. Anatomía del programa, palabra a palabra

Ahora que funciona, vamos a entender cada palabra. Al principio parecerán muchas cosas para mostrar una frase; poco a poco, a lo largo del curso, cada una cobrará sentido.

Anatomía del programa Hola: clase, llaves, método main, println, literal de texto, punto y coma y sangría

Figura 5. Las partes del programa Hola.java.

5.1. La declaración de la clase 

public class Hola {
    ...
}
Elemento Significado
public Modificador de acceso: la clase es pública, cualquiera puede usarla. Lo estudiarás en el módulo 11
class Palabra reservada que indica que empieza la definición de una clase. En Java, todo el código vive dentro de clases
Hola El nombre de la clase. Por convención empieza por mayúscula (PascalCase). Una clase public debe guardarse en un fichero con su mismo nombre: Hola.java
{ ... } Las llaves delimitan el cuerpo de la clase: todo lo que contiene la clase va entre ellas. Cada { debe tener su }

📘 Concepto: Una clase es, de momento, el “contenedor” obligatorio de tu programa. A partir del módulo 10 descubrirás que es mucho más: el molde para crear objetos.

5.2. El método main 

public static void main(String[] args) {
    ...
}

Es el punto de entrada del programa: cuando escribes java Hola, la JVM busca este método en la clase Hola y empieza a ejecutar su contenido, línea a línea, de arriba abajo.

Elemento Significado
public El método es público: la JVM, que está “fuera” de tu clase, necesita poder llamarlo
static El método pertenece a la clase y se puede ejecutar sin crear ningún objeto. Lo entenderás en el módulo 11
void El método no devuelve ningún valor al terminar (“vacío”). Lo verás en el módulo 07
main El nombre del método. Tiene que ser exactamente main, en minúsculas
(String[] args) Los parámetros: un array ([]) de cadenas de texto (String) llamado args con los argumentos que se escriban en la línea de comandos (por ejemplo, java Hola Ana Luis). Lo usarás en el módulo 04
{ ... } El cuerpo del método: las instrucciones que se ejecutan

5.3. La instrucción 

System.out.println("¡Hola, mundo!");
Elemento Significado
System Una clase de la biblioteca estándar que representa el sistema en el que se ejecuta el programa
. El operador punto sirve para acceder a algo que está dentro de otra cosa
out La salida estándar del sistema (normalmente, la consola). Es un objeto de tipo PrintStream
println Un método de out que escribe el texto y salta a la línea siguiente (print line)
( ... ) Los paréntesis contienen los argumentos que le pasamos al método: lo que queremos escribir
"¡Hola, mundo!" Un literal de cadena (String): texto entre comillas dobles
; El punto y coma marca el final de la sentencia. Cada instrucción simple termina en ;

💡 Consejo: Lee System.out.println("Hola") como “en el sistema, en su salida, imprime una línea con el texto Hola”.

Una variante es System.out.print, que escribe sin saltar de línea. Lo verás en profundidad en el módulo 04, junto con printf.

5.4. Reglas de escritura que debes conocer ya

  • Java distingue mayúsculas de minúsculas (case sensitive): System, system y SYSTEM son tres cosas distintas. Solo la primera existe.
  • Los espacios y saltos de línea entre palabras dan igual al compilador. Este programa compila, pero es ilegible:
public class Hola{public static void main(String[]args){System.out.println("¡Hola, mundo!");}}
  • Por eso se usa la sangría (indentación): 4 espacios por cada nivel de llaves. Es una convención universal en Java y el IDE la aplica automáticamente.
  • Las llaves se abren al final de la línea que inicia el bloque y se cierran en una línea propia, alineadas con el inicio de ese bloque (estilo habitual en Java).

5.5. Comentarios

Los comentarios son texto para las personas: el compilador los ignora por completo. Hay tres tipos:

/**
 * Programa de ejemplo con los tres tipos de comentarios.
 * Este es un comentario de documentación (Javadoc).
 */
public class Comentarios {
    public static void main(String[] args) {
        // Comentario de una línea: el compilador lo ignora
        System.out.println("Los comentarios no se ejecutan");

        /* Comentario de varias líneas:
           útil para explicar algo más largo
           o para desactivar temporalmente un bloque de código */
        // System.out.println("Esta línea está comentada y no se ejecuta");

        System.out.println("Fin del programa"); // también al final de una línea
    }
}

Salida:

Los comentarios no se ejecutan
Fin del programa
Tipo Sintaxis Uso
De una línea // texto Aclaraciones breves
De varias líneas /* texto */ Explicaciones largas o desactivar código
De documentación /** texto */ Documentar clases y métodos; la herramienta javadoc genera páginas web con ellos (módulo 20)

💡 Consejo: Un buen comentario explica por qué haces algo, no qué hace cada línea (eso ya lo dice el código). Al principio, sin embargo, es útil comentar mucho para fijar lo que vas aprendiendo.

6. La forma compacta de Java 25: void main() e IO

Explicar public static void main(String[] args) el primer día abruma a cualquiera. Por eso Java 25 (JEP 512) incorporó de forma definitiva los ficheros fuente compactos y los métodos main de instancia. El mismo programa puede escribirse así:

void main() {
    IO.println("¡Hola, mundo!");
}

Se guarda en Hola.java y se ejecuta igual:

java Hola.java

¡Hola, mundo!

También puedes compilarlo con javac Hola.java (genera Hola.class) y ejecutarlo con java Hola.

6.1. ¿Qué ha cambiado?

Forma clásica Forma compacta (Java 25) Explicación
public class Hola { ... } (no se escribe) El compilador crea una clase implícita con los métodos y variables del fichero
public static void main(String[] args) void main() main ya no tiene por qué ser public ni static, y los parámetros son opcionales
System.out.println(...) IO.println(...) java.lang.IO es una clase nueva de Java 25 con métodos sencillos de entrada/salida
import java.util.Scanner; (no hace falta) Un fichero compacto importa automáticamente todo el módulo java.base (java.util, java.io, java.time…)

La clase IO también permite leer del teclado de forma muy sencilla con IO.readln:

void main() {
    String nombre = IO.readln("¿Cómo te llamas? ");
    IO.println("Encantado de conocerte, " + nombre + ".");
    IO.println("Tu nombre tiene " + nombre.length() + " letras.");
}

Al ejecutarlo y escribir Ana:

¿Cómo te llamas? Ana
Encantado de conocerte, Ana.
Tu nombre tiene 3 letras.

Un fichero compacto puede tener variables y varios métodos:

// Un fichero compacto puede tener varios métodos y variables
String saludo = "Hola";

void main() {
    saludar("Ana");
    saludar("Luis");
    IO.println("Hoy es " + java.time.LocalDate.of(2026, 10, 5).getDayOfWeek());
}

void saludar(String nombre) {
    IO.println(saludo + ", " + nombre + "!");
}

Hola, Ana!
Hola, Luis!
Hoy es MONDAY

6.2. ¿Cuál usaremos en el curso?

⚠️ Importante: En este curso escribiremos los programas con la forma clásica (public class + public static void main(String[] args) + System.out.println). Es la que encontrarás en el código profesional, en los libros, en los exámenes y en todas las versiones de Java anteriores a la 25. La forma compacta es estupenda para pruebas rápidas y la usaremos como alternativa moderna en algunos ejemplos, indicándolo siempre.

Ten en cuenta también que:

  • Un fichero compacto no puede tener package ni ser usado por nombre desde otras clases: está pensado para programas pequeños de un solo fichero.
  • Si un compañero usa Java 21 o anterior, el código compacto no le compilará.
  • La clase IO puede usarse también desde una clase normal: IO.println("Hola"); funciona en cualquier programa con Java 25.

7. JShell: probar Java línea a línea

JShell (incluido en el JDK desde Java 9) es una consola interactiva o REPL (Read-Eval-Print Loop): escribes una expresión o una instrucción, la ejecuta al momento y te muestra el resultado. No hace falta clase, ni main, ni compilar. Es ideal para experimentar.

Ábrelo desde la terminal:

jshell

Sesión real con el JDK 25 (lo que escribes va detrás de jshell>):

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

jshell> 2 + 3
$1 ==> 5

jshell> int edad = 18
edad ==> 18

jshell> edad + 1
$3 ==> 19

jshell> String nombre = "Ana"
nombre ==> "Ana"

jshell> nombre.length()
$5 ==> 3

jshell> nombre.toUpperCase()
$6 ==> "ANA"

jshell> Math.sqrt(16)
$7 ==> 4.0

jshell> 10 / 3
$8 ==> 3

jshell> 10.0 / 3
$9 ==> 3.3333333333333335

jshell> System.out.println("Hola desde JShell")
Hola desde JShell

jshell> /vars
|    int $1 = 5
|    int edad = 18
|    int $3 = 19
|    String nombre = "Ana"
|    int $5 = 3
|    String $6 = "ANA"
|    double $7 = 4.0
|    int $8 = 3
|    double $9 = 3.3333333333333335

jshell> /exit
|  Goodbye

Observa algunas cosas:

  • En JShell no hace falta el ; al final de una línea simple (aunque puedes ponerlo).
  • Cuando una expresión no se guarda en ninguna variable, JShell crea variables temporales $1, $2…
  • 10 / 3 da 3 y 10.0 / 3 da 3.3333333333333335. ¿Por qué? Lo descubrirás en el módulo 03 (división entera y precisión de los double).
Comando Qué hace
/help Ayuda general
/vars Lista las variables definidas
/list Muestra todo lo que has escrito
/imports Muestra los import activos
/reset Borra todo y empieza de cero
/exit Sale de JShell
Tecla Tab Autocompleta nombres de clases y métodos (escribe Math. y pulsa Tab)
Flechas ↑ ↓ Recuperan líneas anteriores

💡 Consejo: Ten JShell a mano mientras estudias los módulos 03 y 04. ¿Dudas de qué da 7 % 3 o (int) 3.99? Compruébalo en dos segundos.

8. IntelliJ IDEA

IntelliJ IDEA, de la empresa JetBrains, es el IDE más usado para Java. Desde la versión 2025.3 se distribuye como un único producto: sus funciones principales son gratuitas, y las avanzadas (desarrollo web empresarial, Spring, bases de datos completas…) requieren una suscripción Ultimate, con prueba gratuita de 30 días. Los estudiantes y docentes pueden solicitar una licencia educativa gratuita en la web de JetBrains. Para este curso basta con las funciones gratuitas.

8.1. Instalación

Requisitos mínimos según JetBrains: procesador de 64 bits con 4 núcleos, 8 GB de RAM, 10 GB de disco y pantalla de 1280 × 720. No necesita que tengas Java instalado para funcionar (incluye su propio entorno, el JetBrains Runtime), aunque sí necesitas el JDK 25 para compilar tus programas.

Sistema Forma recomendada Alternativa
Windows Toolbox App de JetBrains (gestiona instalaciones y actualizaciones) Instalador .exe de jetbrains.com/idea/download
macOS Toolbox App Imagen .dmg (elige Apple Silicon o Intel) y arrastrar a Aplicaciones
Linux Toolbox App sudo snap install intellij-idea --classic, o el .tar.gz y ejecutar bin/idea.sh

Si usas el instalador .exe de Windows, en el paso Installation Options puedes marcar:

  • Crear un acceso directo en el escritorio.
  • Añadir al PATH la carpeta con los lanzadores de línea de comandos (para poder abrir el IDE desde la terminal).
  • Añadir la acción Open Folder as Project al menú contextual de las carpetas.
  • Asociar extensiones (como .java) con IntelliJ IDEA.

La primera vez que lo abras te preguntará si quieres importar ajustes de otra instalación y te mostrará la pantalla de bienvenida (Welcome to IntelliJ IDEA), con los botones New Project, Open y Clone Repository.

💡 Consejo: La interfaz de IntelliJ IDEA está en inglés. Merece la pena acostumbrarse: los nombres de las opciones coinciden con la documentación oficial y con los tutoriales, y en el mundo profesional todo el mundo usa esos términos.

8.2. Crear un proyecto: el asistente New Project

En la pantalla de bienvenida pulsa New Project (o, con un proyecto abierto, menú ☰ → File → New → Project…).

Esquema del asistente New Project de IntelliJ IDEA con Java seleccionado, nombre HolaMundo, build system IntelliJ y JDK 25

Figura 6. Esquema del asistente New Project de IntelliJ IDEA.

  1. ① En la lista de la izquierda, selecciona Java. (Debajo, en Generators, hay plantillas para Maven, Spring Boot, JavaFX… que usarás en el Curso de Java Avanzado.)
  2. ② Name: el nombre del proyecto, por ejemplo HolaMundo. Location: la carpeta donde se creará (por defecto IdeaProjects dentro de tu carpeta de usuario). Debajo verás la ruta final del proyecto. Deja desmarcado Create Git repository por ahora (Git se ve en el módulo 20).
  3. ③ Build system: elige IntelliJ, el sistema de compilación propio del IDE, el más sencillo. Maven y Gradle son herramientas profesionales de construcción de proyectos que verás más adelante.
  4. ④ JDK: selecciona el 25. Si ya lo instalaste, aparecerá en la lista. Si no, puedes descargarlo desde aquí mismo (sección 8.3).
  5. ⑤ Add sample code: si lo marcas, IntelliJ crea un fichero Main.java de ejemplo (y la opción Generate code with onboarding tips le añade comentarios con trucos del IDE). Para este primer proyecto, déjalo desmarcado: escribiremos nosotros el código.
  6. ⑥ Pulsa Create.

8.3. Descargar un JDK desde IntelliJ IDEA

Si en el desplegable JDK no aparece el 25, IntelliJ puede descargarlo e instalarlo por ti:

Esquema del desplegable JDK con la opción Download JDK y del diálogo Download JDK con versión 25 y Eclipse Temurin

Figura 7. Esquema de la descarga de un JDK desde IntelliJ IDEA.

  • ① Abre el desplegable JDK y elige Download JDK… (la opción Add JDK from disk… sirve para indicar un JDK ya instalado en una carpeta).
  • ② Version: 25.
  • ③ Vendor: Eclipse Temurin (u Oracle OpenJDK, Amazon Corretto…).
  • ④ Pulsa Download. Se instalará en la carpeta .jdks de tu usuario.

⚠️ Importante: El JDK que descarga IntelliJ solo lo conoce IntelliJ: no modifica JAVA_HOME ni el PATH. Si también quieres usar javac en la terminal, instala el JDK como se explica en la sección 2.

8.4. La ventana principal y la estructura del proyecto

Tras pulsar Create, se abre la ventana principal. Crea tu clase: en la ventana Project, haz clic derecho sobre la carpeta src → New → Java Class, escribe Hola y pulsa Enter. IntelliJ crea el fichero Hola.java con el esqueleto de la clase:

public class Hola {
}

Coloca el cursor dentro de las llaves, escribe psvm (o main) y pulsa Tab: IntelliJ escribe el método main completo. Dentro de él, escribe sout y pulsa Tab: aparece System.out.println();. Escribe el texto entre los paréntesis. Estas abreviaturas se llaman plantillas en vivo (live templates).

💡 Consejo: En el menú New también verás la opción Java Compact File, que crea un fichero con la forma compacta de Java 25 (void main()). Para seguir el curso, usa Java Class.

Esquema de la ventana principal de IntelliJ IDEA con la ventana Project, el editor con Hola.java, los iconos de ejecución y la ventana Run con la salida

Figura 8. Esquema de la ventana principal de IntelliJ IDEA tras ejecutar Hola.

  • ① Ventana Project (atajo Alt+1): el árbol de carpetas y ficheros del proyecto.
  • ② Editor: donde escribes el código. Colorea la sintaxis, subraya los errores en rojo mientras escribes y te sugiere cómo completar.
  • ③ Iconos ▶ del margen (gutter): aparecen junto a las clases que tienen main. Haz clic y elige Run ‘Hola.main()’.
  • ④ Widget de ejecución de la barra superior: muestra la última configuración ejecutada (Hola), con los botones Run ▶ (Shift+F10) y Debug (el depurador, módulo 19).
  • ⑤ Ventana Run (atajo Alt+4): la consola donde aparece la salida del programa. La primera línea gris es el comando java que ha lanzado el IDE; al final, Process finished with exit code 0 indica que el programa terminó sin errores (un código distinto de 0 indica un error).

Estructura del proyecto en disco:

HolaMundo/
├── .idea/                  ← configuración del proyecto para IntelliJ (no la toques)
├── out/                    ← se crea al compilar: aquí van los .class
│   └── production/
│       └── HolaMundo/
│           └── Hola.class
├── src/                    ← tu código fuente (carpeta azul = sources root)
│   └── Hola.java
├── .gitignore              ← lista de ficheros que Git debe ignorar
└── HolaMundo.iml           ← descripción del módulo para IntelliJ
Elemento Qué es
src Raíz de fuentes (sources root). Tus ficheros .java van aquí (o en subcarpetas que serán paquetes, módulo 11)
out Carpeta de salida: IntelliJ compila tus .java y deja aquí los .class
.idea y .iml Configuración interna del IDE. No hace falta entregarla en las prácticas
External Libraries En la ventana Project, muestra el JDK (< 25 >) y las bibliotecas que usa el proyecto
Scratches and Consoles Ficheros de borrador para pruebas rápidas

⚠️ Importante: Cuando entregues una práctica, entrega la carpeta src (o el proyecto entero sin la carpeta out). Los .class se generan de nuevo al compilar.

8.5. Ayudas del editor

Mientras escribes, IntelliJ:

  • Subraya en rojo los errores de compilación y te dice qué pasa al pasar el ratón por encima.
  • Muestra una bombilla 💡 con soluciones rápidas: pulsa Alt+Enter sobre el error (por ejemplo, para añadir un import que falta).
  • Autocompleta nombres al escribir; si la lista no aparece, pulsa Ctrl+Espacio.
  • Muestra en gris, dentro del código, el nombre de los parámetros de los métodos (inlay hints).

Atajos de teclado que te ahorrarán mucho tiempo:

Acción Windows / Linux macOS
Ejecutar Shift+F10 Ctrl+R
Ejecutar el fichero actual Ctrl+Shift+F10 Ctrl+Shift+R
Depurar Shift+F9 Ctrl+D
Autocompletar Ctrl+Espacio Ctrl+Espacio
Ver soluciones rápidas Alt+Enter Option+Enter
Reformatear el código Ctrl+Alt+L Cmd+Option+L
Comentar/descomentar línea Ctrl+/ Cmd+/
Duplicar línea Ctrl+D Cmd+D
Renombrar (en todo el proyecto) Shift+F6 Shift+F6
Nuevo fichero/clase Alt+Insert Cmd+N
Buscar en todas partes Shift dos veces Shift dos veces
Buscar una acción del IDE Ctrl+Shift+A Cmd+Shift+A
Ajustes Ctrl+Alt+S Cmd+,

Plantillas en vivo más útiles:

Escribe… …y pulsa Tab Resultado
psvm o main Tab public static void main(String[] args) { }
sout Tab System.out.println();
souf Tab System.out.printf("");
fori Tab Un bucle for con contador (módulo 06)

8.6. Ajustes útiles

Abre los ajustes con Ctrl+Alt+S (o menú ☰ → File → Settings; en macOS, IntelliJ IDEA → Settings).

Esquema del diálogo Settings de IntelliJ IDEA en Editor, Font con el tamaño de letra 16

Figura 9. Esquema del diálogo Settings de IntelliJ IDEA (Editor › Font).

  • ① El buscador de la parte superior izquierda es la forma más rápida de encontrar cualquier ajuste: escribe “font”, “encoding”, “import”…
  • ② En el árbol, Editor → Font.
  • ③ Size: sube el tamaño de letra a 16 o más. Tu vista lo agradecerá (y la de quien mire tu pantalla en clase).
  • ④ Pulsa OK (o Apply para aplicarlo sin cerrar).
Ajuste Dónde Recomendación
Tamaño de letra del editor Editor → Font 16 o más
Tema claro/oscuro Appearance & Behavior → Appearance El que te resulte más cómodo
Importaciones automáticas Editor → General → Auto Import Activa Add unambiguous imports on the fly y Optimize imports on the fly
Codificación de ficheros Editor → File Encodings UTF-8 en todas las opciones
Cambiar el tamaño con la rueda Editor → General Change font size with Ctrl+Mouse Wheel
Estilo del código Editor → Code Style → Java Deja el predeterminado (4 espacios)
Mapa de teclas Keymap Si vienes de otro editor, puedes elegir sus atajos

💡 Consejo: IntelliJ IDEA incluye asistentes de inteligencia artificial que completan líneas o funciones enteras. Mientras aprendes, escribe tú el código: el objetivo del curso es que aprendas a pensar los algoritmos, no a aceptar sugerencias. Si te distraen, puedes desactivar la finalización de código con IA en los ajustes (busca “completion” o “AI” en el buscador).

9. Alternativa: Visual Studio Code

Visual Studio Code (VS Code), de Microsoft, es un editor gratuito, ligero y muy popular. No es un IDE de Java “de serie”, pero con las extensiones adecuadas se convierte en uno muy capaz. Es buena opción si tu ordenador tiene poca memoria o si ya lo usas para otros lenguajes.

  1. Instala el JDK 25 y configura JAVA_HOME (sección 2). VS Code lo detecta a partir de esa variable.
  2. Descarga VS Code de code.visualstudio.com e instálalo.
  3. En la barra lateral, abre Extensiones (Ctrl+Shift+X), busca Extension Pack for Java (de Microsoft) y pulsa Install.
  4. Abre tu carpeta de trabajo con File → Open Folder…, crea un fichero Hola.java y escribe el programa.
  5. Encima del método main aparecen los enlaces **Run Debug. Pulsa **Run.

Esquema de VS Code con la vista de extensiones mostrando el Extension Pack for Java, el editor con Run y Debug sobre main y el terminal con la salida

Figura 10. Esquema de VS Code con el Extension Pack for Java.

  • ① Icono de la vista Extensions en la barra de actividad.
  • ② La extensión Extension Pack for Java, que instala de una vez seis extensiones: Language Support for Java™ by Red Hat (autocompletado, errores, refactorización), Debugger for Java, Test Runner for Java, Maven for Java, Gradle for Java y Project Manager for Java.
  • ③ Los enlaces **Run Debug** que aparecen sobre main.
  • ④ El panel TERMINAL, donde VS Code lanza java y aparece la salida del programa.

Para crear un proyecto organizado, abre la paleta de comandos (Ctrl+Shift+P), escribe Java: Create Java Project y elige No build tools: VS Code crea una carpeta de proyecto con src para el código fuente y lib para las bibliotecas.

10. Otros IDE: Eclipse y NetBeans

IDE Comentario
Eclipse IDE for Java Developers Gratuito y de código abierto (Fundación Eclipse). Muy extendido en empresas y en centros educativos durante años. Organiza los proyectos en un workspace
Apache NetBeans Gratuito y de código abierto (Fundación Apache). Muy sencillo para empezar y con un buen diseñador de interfaces gráficas (Swing)
IntelliJ IDEA El más usado hoy en el desarrollo profesional con Java. El que usaremos en el curso
VS Code Editor ligero y versátil; con el Extension Pack for Java es una alternativa válida

Todos hacen lo mismo en esencia: llaman a javac y a java por ti. Lo que aprendas en uno se traslada fácilmente a otro.

11. Errores típicos de compilación y cómo leerlos

Vas a ver muchos errores. Es normal y no significa que lo estés haciendo mal: hasta los programadores con décadas de experiencia los cometen a diario. La diferencia es que saben leerlos.

11.1. Cómo se lee un mensaje de error 

Hola.java:3: error: ';' expected
        System.out.println("¡Hola, mundo!")
                                           ^
1 error
Parte Significado
Hola.java El fichero donde está el error
:3: El número de línea
error: Es un error (a veces verás warning:, un aviso que no impide compilar)
';' expected La descripción: “se esperaba un ;”
La línea de código La línea donde el compilador detectó el problema
^ El acento circunflejo señala la posición exacta
1 error El número total de errores

⚠️ Importante: Los mensajes del compilador están en inglés (el JDK no los traduce al español). Las frases son siempre las mismas y enseguida las reconocerás. Y recuerda: corrige siempre el primer error primero. Un solo fallo puede provocar varios mensajes en cascada, y al corregir el primero muchas veces desaparecen los demás.

Todos los mensajes siguientes son reales, obtenidos con javac 25 sobre el programa Hola.java con un fallo cada vez.

11.2. Falta el punto y coma 

        System.out.println("¡Hola, mundo!")

Hola.java:3: error: ';' expected
        System.out.println("¡Hola, mundo!")
                                           ^
1 error

Solución: añade ; al final de la sentencia. Si falta al final de una línea, el compilador lo indica justo detrás del último carácter.

11.3. Nombre mal escrito: Sytem 

        Sytem.out.println("¡Hola, mundo!");

Hola.java:3: error: package Sytem does not exist
        Sytem.out.println("¡Hola, mundo!");
             ^
1 error

El compilador no conoce nada llamado Sytem y, como hay un punto detrás, supone que es el nombre de un paquete (una carpeta de clases). Solución: escribe System.

11.4. Mayúsculas y minúsculas: system 

        system.out.println("¡Hola, mundo!");

Hola.java:3: error: package system does not exist
        system.out.println("¡Hola, mundo!");
              ^
1 error

Solución: System empieza por mayúscula. Recuerda: Java distingue mayúsculas de minúsculas.

11.5. Método mal escrito: printl 

        System.out.printl("¡Hola, mundo!");

Hola.java:3: error: cannot find symbol
        System.out.printl("¡Hola, mundo!");
                  ^
  symbol:   method printl(String)
  location: variable out of type PrintStream
1 error

cannot find symbol (“no encuentro el símbolo”) es el error más frecuente de todos. Las líneas symbol y location te dicen qué no encuentra (un método printl que reciba un String) y dónde lo ha buscado (en la variable out, de tipo PrintStream). Solución: println.

11.6. Comillas sin cerrar 

        System.out.println("¡Hola, mundo!);

Hola.java:3: error: unclosed string literal
        System.out.println("¡Hola, mundo!);
                           ^
1 error

Solución: cierra el texto con ". El ^ apunta a la comilla que abre la cadena que nunca se cierra.

11.7. Comillas simples en lugar de dobles 

        System.out.println('¡Hola, mundo!');

Hola.java:3: error: unclosed character literal
        System.out.println('¡Hola, mundo!');
                           ^
Hola.java:3: error: not a statement
        System.out.println('¡Hola, mundo!');
                             ^
Hola.java:3: error: ';' expected
        System.out.println('¡Hola, mundo!');
                                 ^
Hola.java:3: error: not a statement
        System.out.println('¡Hola, mundo!');
                                   ^
Hola.java:3: error: ';' expected
        System.out.println('¡Hola, mundo!');
                                        ^
Hola.java:3: error: unclosed character literal
        System.out.println('¡Hola, mundo!');
                                         ^
6 errors

¡Seis errores por un solo fallo! Es el efecto cascada. En Java, las comillas simples son para un único carácter ('A', módulo 03) y las dobles para textos ("Hola"). El primer mensaje, unclosed character literal, es el que da la pista. Solución: usa comillas dobles.

11.8. Falta una llave de cierre 

public class Hola {
    public static void main(String[] args) {
        System.out.println("¡Hola, mundo!");
    }

Hola.java:4: error: reached end of file while parsing
    }
     ^
1 error

“Se ha llegado al final del fichero mientras se analizaba”: el compilador esperaba una } más. Solución: cuenta las llaves; cada { necesita su }. La sangría correcta ayuda mucho a detectarlo (el IDE resalta la pareja de cada llave al situar el cursor sobre ella).

11.9. El nombre de la clase no coincide con el del fichero

Fichero Hola.java con este contenido:

public class Saludo {

Hola.java:1: error: class Saludo is public, should be declared in a file named Saludo.java
public class Saludo {
       ^
1 error

Solución: renombra el fichero a Saludo.java o la clase a Hola. En IntelliJ, usa Shift+F6 sobre el nombre de la clase y el IDE renombra también el fichero.

11.10. Errores al ejecutar (no al compilar)

Estos programas compilan, pero java no consigue lanzarlos:

main mal escrito (por ejemplo mian) o con parámetros incorrectos (String args en lugar de String[] args):

Error: Main method not found in class Hola, please define the main method as:
   public static void main(String[] args)
or a JavaFX application class must extend javafx.application.Application

Ejecutar con la extensión .class:

java Hola.class

Error: Could not find or load main class Hola.class
Caused by: java.lang.ClassNotFoundException: Hola.class

Nombre de clase con distinta mayúscula (java hola):

Error: Could not find or load main class hola
Caused by: java.lang.NoClassDefFoundError: hola (wrong name: Hola)

Clase que no existe en la carpeta actual (java Adios), o estás en otra carpeta:

Error: Could not find or load main class Adios
Caused by: java.lang.ClassNotFoundException: Adios

Compilar sin la extensión (javac Hola):

error: Class names, 'Hola', are only accepted if annotation processing is explicitly requested
1 error

11.11. Tabla resumen

Mensaje Causa habitual Solución
';' expected Falta ; Añádelo al final de la sentencia
cannot find symbol Nombre mal escrito, variable sin declarar, falta un import Revisa la ortografía y las mayúsculas; Alt+Enter en el IDE
package X does not exist Nombre de clase mal escrito antes de un punto (Sytem., system.) Corrige el nombre
unclosed string literal Falta la " de cierre Cierra la cadena
unclosed character literal Texto entre comillas simples Usa comillas dobles para textos
reached end of file while parsing Falta una } Cuenta las llaves
class X is public, should be declared in a file named X.java Nombre de clase ≠ nombre de fichero Renombra uno de los dos
Main method not found in class X main mal escrito o con parámetros incorrectos public static void main(String[] args)
Could not find or load main class Ejecutas desde otra carpeta, con .class o con otra mayúscula cd a la carpeta y java Nombre
Class names, 'X', are only accepted if annotation processing... javac sin .java javac X.java
UnsupportedClassVersionError Compilado con un JDK más nuevo que la JVM que ejecuta Usa la misma versión (sección 3.1)

12. Organización de carpetas y nombres de ficheros

12.1. Reglas obligatorias

  • Un fichero .java puede contener como máximo una clase public, y el fichero debe llamarse exactamente igual que ella, con la misma combinación de mayúsculas y minúsculas: public class CalculadoraIva → CalculadoraIva.java.
  • El nombre de una clase no puede empezar por un número ni contener espacios, guiones o símbolos como +, ! o .. Tampoco puede ser una palabra reservada (class, public, int…).

12.2. Convenciones (no obligatorias, pero universales)

Elemento Convención Ejemplos correctos Ejemplos a evitar
Clases y ficheros PascalCase: cada palabra empieza por mayúscula Hola, NotaMedia, CalculadoraIva hola, nota_media, Calculadora iva
Métodos y variables camelCase: primera palabra en minúscula main, calcularMedia, precioTotal CalcularMedia, precio_total
Constantes MAYÚSCULAS con guiones bajos IVA_GENERAL ivaGeneral
Paquetes (módulo 11) Todo en minúsculas es.curso.modulo01 Es.Curso

💡 Consejo: Java permite usar tildes y la ñ en los nombres (class Año compila), pero evítalo: da problemas con algunas herramientas, sistemas de ficheros y teclados. Usa Anio o, mejor, un nombre en otro sentido (Ejercicio, Calendario).

12.3. Una estructura recomendada para el curso

Con la terminal:

C:\java\
├── m01\
│   ├── Hola.java
│   ├── Presentacion.java
│   └── Taza.java
├── m02\
│   └── ...
└── m03\
    └── ...

Con IntelliJ IDEA, lo más cómodo es un proyecto por módulo del curso (por ejemplo, Modulo01, Modulo02…) y una clase por ejercicio dentro de src. Cada clase con su propio main se puede ejecutar por separado con el icono ▶ del margen.

13. Ejercicios

Ejercicio 1: Comprueba tu instalación

Instala el JDK 25, configura JAVA_HOME y PATH, y escribe en una terminal nueva los comandos necesarios para comprobar: la versión de java, la versión de javac, el valor de JAVA_HOME y la carpeta de la que se está ejecutando javac. ¿Qué debes ver para saber que todo está bien?

Ver solución

En PowerShell:

java -version
javac -version
$env:JAVA_HOME
where.exe javac

Debes comprobar que:

  1. java -version muestra la versión 25 (por ejemplo openjdk version "25.0.4.1" 2026-08-18 LTS).
  2. javac -version muestra la misma versión (javac 25.0.4.1).
  3. $env:JAVA_HOME muestra la carpeta del JDK 25, sin \bin al final (por ejemplo C:\Program Files\Eclipse Adoptium\jdk-25.0.1.8-hotspot).
  4. where.exe javac muestra como primera línea ...\jdk-25...\bin\javac.exe. Si aparecen varias líneas, Windows usará la primera.

En macOS o Linux, los equivalentes son echo $JAVA_HOME y which javac.

Ejercicio 2: Preséntate

Escribe un programa Presentacion.java que muestre cuatro líneas con tu nombre, tus estudios, tu ciudad y una afición. Compílalo con javac y ejecútalo con java desde la terminal.

Ver solución 
// Ejercicio: presentación personal
public class Presentacion {
    public static void main(String[] args) {
        System.out.println("Nombre: Lucía Martín");
        System.out.println("Estudios: 1.º de DAM");
        System.out.println("Ciudad: Valencia");
        System.out.println("Afición: los videojuegos de estrategia");
    }
}

javac Presentacion.java
java Presentacion

Salida:

Nombre: Lucía Martín
Estudios: 1.º de DAM
Ciudad: Valencia
Afición: los videojuegos de estrategia

Cada println escribe su texto y salta de línea, por eso salen cuatro líneas. Fíjate en que el fichero se llama igual que la clase: Presentacion.java.

Ejercicio 3: Caza los errores

Este programa tiene tres errores. Intenta encontrarlos leyendo el código y después compílalo para ver qué dice javac:

public class Saludo {
    public static void main(String[] args) {
        System.out.println("Buenos días")
        System.out.printn("Bienvenido al curso");
        system.out.println("Empezamos");
    }
}
Ver solución

Al compilar la primera vez, javac solo informa de un error:

Saludo.java:3: error: ';' expected
        System.out.println("Buenos días")
                                         ^
1 error

¿Por qué solo uno? El compilador trabaja en fases: primero comprueba que la estructura (la sintaxis) es correcta y, si no lo es, se detiene antes de comprobar si los nombres existen. Al añadir el ; y compilar de nuevo, aparecen los otros dos:

Saludo.java:4: error: cannot find symbol
        System.out.printn("Bienvenido al curso");
                  ^
  symbol:   method printn(String)
  location: variable out of type PrintStream
Saludo.java:5: error: package system does not exist
        system.out.println("Empezamos");
              ^
2 errors

Programa corregido:

public class Saludo {
    public static void main(String[] args) {
        System.out.println("Buenos días");
        System.out.println("Bienvenido al curso");
        System.out.println("Empezamos");
    }
}

Buenos días
Bienvenido al curso
Empezamos

Moraleja: que desaparezca un error no significa que no haya más. Compila, corrige el primero y repite.

Ejercicio 4: Dibujo con texto

Escribe un programa Taza.java que dibuje una taza de café humeante con caracteres (arte ASCII) y debajo el texto J A V A 2 5. Pista: para mostrar una barra invertida \ dentro de un texto tienes que escribir \\ (lo explicamos en el módulo 04).

Ver solución 
public class Taza {
    public static void main(String[] args) {
        System.out.println("     ( (");
        System.out.println("      ) )");
        System.out.println("   ........");
        System.out.println("   |      |]");
        System.out.println("   \\      /");
        System.out.println("    `----'");
        System.out.println("  J A V A  2 5");
    }
}

Salida:

     ( (
      ) )
   ........
   |      |]
   \      /
    `----'
  J A V A  2 5

Los espacios dentro de las comillas sí cuentan: forman parte del texto y se muestran tal cual. En la quinta línea, \\ se muestra como una sola \, porque la barra invertida tiene un significado especial dentro de las cadenas (las secuencias de escape, módulo 04).

Ejercicio 5: Versión compacta

Reescribe el programa del ejercicio 2 con la forma compacta de Java 25 y ejecútalo con el lanzamiento directo de código fuente.

Ver solución

Fichero PresentacionCompacta.java:

void main() {
    IO.println("Nombre: Lucía Martín");
    IO.println("Estudios: 1.º de DAM");
    IO.println("Ciudad: Valencia");
    IO.println("Afición: los videojuegos de estrategia");
}

java PresentacionCompacta.java

Nombre: Lucía Martín
Estudios: 1.º de DAM
Ciudad: Valencia
Afición: los videojuegos de estrategia

Desaparecen la declaración de la clase, public static, los parámetros de main y System.out. La salida es idéntica. Recuerda que esto solo funciona con Java 25 o posterior.

Ejercicio 6: Calculadora JShell

Usa JShell para calcular: el área de un círculo de radio 5 (usa 3.14159 como valor de π), los segundos que tiene un día y los segundos que tiene un año de 365 días. Después, prueba a unir un texto y un número con +.

Ver solución 
jshell> 3.14159 * 5 * 5
$1 ==> 78.53975

jshell> 60 * 60 * 24
$2 ==> 86400

jshell> 60 * 60 * 24 * 365
$3 ==> 31536000

jshell> "Java " + 25
$4 ==> "Java 25"

jshell> /exit
|  Goodbye

Cuando sumas un texto y un número, Java une (concatena) ambos y el resultado es un texto: "Java 25". En el módulo 03 verás que la forma correcta de obtener π es Math.PI.

Ejercicio 7: print frente a println

Sin ejecutarlo, escribe en un papel lo que mostrará este programa. Después compruébalo.

public class PrintVsPrintln {
    public static void main(String[] args) {
        System.out.print("Uno ");
        System.out.print("Dos ");
        System.out.println("Tres");
        System.out.println("Cuatro");
        System.out.print("Cinco");
        System.out.println();
        System.out.println("Seis " + "Siete");
        System.out.println("2 + 3 = " + 2 + 3);
        System.out.println("2 + 3 = " + (2 + 3));
    }
}
Ver solución 
Uno Dos Tres
Cuatro
Cinco
Seis Siete
2 + 3 = 23
2 + 3 = 5
  • print no salta de línea, así que “Uno”, “Dos” y “Tres” salen en la misma línea; el salto llega con el println de “Tres”.
  • System.out.println() sin nada dentro solo hace un salto de línea (termina la línea de “Cinco”).
  • La penúltima línea es una trampa clásica: Java evalúa de izquierda a derecha. "2 + 3 = " + 2 da el texto "2 + 3 = 2", y al sumarle 3 se concatena otra vez: "2 + 3 = 23". Con paréntesis, primero se calcula 2 + 3 = 5 y luego se concatena. Lo estudiarás a fondo en el módulo 03.

Ejercicio 8 (propuesto): Proyecto en IntelliJ IDEA

Crea en IntelliJ IDEA un proyecto llamado Modulo01 con Build system IntelliJ y JDK 25. Crea dentro las clases Hola, Presentacion y Taza de este módulo y ejecuta cada una con el icono ▶ del margen. Localiza en el explorador de archivos la carpeta out y comprueba que contiene los .class.

Ejercicio 9 (propuesto): Provoca los errores

Partiendo del programa Hola.java correcto, provoca a propósito uno a uno los errores de la sección 11 (quita un ;, cambia una mayúscula, borra una llave…) y compila. Anota en una tabla cada cambio, el mensaje que obtienes y la línea que indica. ¿En algún caso la línea del error no es la línea donde está realmente el fallo?

Ejercicio 10 (propuesto): Tarjeta de visita

Escribe un programa Tarjeta.java que muestre una tarjeta de visita enmarcada con caracteres +, - y |, con tu nombre, tu correo electrónico ficticio y tu ciclo o grado. Todas las líneas del marco deben quedar alineadas.

Ejercicio 11 (propuesto): Dos ejecuciones

Para el programa del ejercicio 10, ejecútalo de las dos formas: compilando con javac y ejecutando con java, y con el lanzamiento directo java Tarjeta.java. Después, borra el .class, modifica un texto y ejecuta java Tarjeta sin recompilar. ¿Qué ocurre? ¿Y si no lo hubieras borrado?

Ejercicio 12 (propuesto): VS Code

Instala VS Code y el Extension Pack for Java, abre la carpeta de tus ejercicios y ejecuta Presentacion.java con el enlace Run. Compara la experiencia con IntelliJ IDEA: ¿qué te ha resultado más cómodo de cada uno?

Ejercicio 13 (propuesto): Explora JShell

En JShell, escribe Math. y pulsa Tab para ver los métodos disponibles. Prueba al menos cinco de ellos (por ejemplo, Math.max(3, 8), Math.abs(-5), Math.pow(2, 10)…) y apunta qué crees que hace cada uno. Lo comprobarás en el módulo 03.

Resumen

Concepto Sintaxis / dónde Para qué
Instalar el JDK adoptium.net (Temurin) u oracle.com Tener javac, java, jshell…
JAVA_HOME Carpeta raíz del JDK, sin \bin Que las herramientas sepan qué JDK usar
PATH Añadir %JAVA_HOME%\bin Usar java y javac desde cualquier carpeta
Comprobar versión java -version y javac -version Ambas deben indicar 25
Compilar javac Hola.java Genera Hola.class
Ejecutar java Hola Lanza la JVM con la clase Hola
Lanzamiento directo java Hola.java Compila en memoria y ejecuta (Java 11+; varios ficheros desde Java 22)
Estructura clásica public class Hola { public static void main(String[] args) { ... } } Forma estándar de un programa
Mostrar texto System.out.println("texto"); Escribe y salta de línea
Forma compacta (Java 25) void main() { IO.println("texto"); } Programas pequeños sin clase explícita
Comentarios //, /* */, /** */ Explicaciones para personas
JShell jshell, /vars, /exit Probar código al momento
IntelliJ IDEA New Project → Java, Build system IntelliJ, JDK 25 IDE del curso
Plantillas en vivo psvm/main + Tab, sout + Tab Escribir main y println rápidamente
Ejecutar en IntelliJ ▶ del margen o Shift+F10 Compilar y ejecutar
VS Code Extension Pack for Java Alternativa ligera
Leer errores Fichero.java:línea: error: descripción + ^ Corregir siempre el primero
Nombres Clase pública = nombre del fichero, PascalCase CalculadoraIva.java
Navegación  
← Módulo anterior: Introducción a la programación y a Java Siguiente módulo: Algoritmos, pseudocódigo y diagramas de flujo →