1. ¿Qué es programar? Java en el mundo real

UD1 — Fundamentos de Programación · RA1 — Reconocer la estructura de un programa informático

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.1 — Se han identificado los bloques que componen la estructura de un programa informático.
Marco normativo	RD 405/2023 · RD 450/2010 · RD 659/2023
Tecnología base	Java 25 LTS (OpenJDK Temurin 25) — soporte hasta 2030+

Introducción de la sección

Bienvenido a tu primera clase real de programación. Si has llegado hasta aquí es porque, seguramente, llevas tiempo pensando que "alguien tiene que haber escrito eso" cada vez que usas WhatsApp, haces una transferencia bancaria o juegas a algo en el móvil. Ese alguien puede ser tú dentro de dos años. La buena noticia es que nadie nace sabiendo programar, y Java es uno de los caminos más sólidos para empezar. La aparentemente mala noticia es que vas a tener que desaprender un par de cosas que crees saber sobre cómo "piensa" un ordenador. Empezamos por el principio, que es justo lo que toca.

En esta sección no vas a escribir todavía ni una línea de Java. Antes de manejar la herramienta necesitas entender qué es lo que tienes entre manos: qué es un programa, por qué existe Java, qué pinta tiene su máquina virtual y por qué tu profesor te obliga a instalar tres siglas raras (JDK, JRE, JVM) antes de pulsar "Run". Conviene que te conformes con esto: al terminar la sección sabrás por qué Java lleva 30 años en lo más alto y por qué Java 25, concretamente, es una versión LTS que te va a acompañar hasta 2030.

1.1 Concepto de programa, algoritmo e instrucción

La receta de cocina que es todo

Imagina que quieres preparar una tortilla de patatas y se lo explicas a alguien que nunca ha cocinado. No le vale con decirle "haz una tortilla"; tienes que descomponerlo en pasos tan pequeños que no haya lugar a dudas: "pela tres patatas", "córtalas en láminas finas", "pon aceite a fuego medio", "fríe las patatas 10 minutos", "bate tres huevos", "mezcla", "cuajas 4 minutos por cada lado". Esa secuencia ordenada, finita y sin ambigüedad de pasos para resolver un problema es lo que llamamos un algoritmo.

Cada uno de esos pasos individuales ("pela tres patatas") es una instrucción: la unidad mínima con sentido propio que le damos a quien ejecuta. Y la receta completa, escrita en un idioma concreto (español, inglés, o el lenguaje de programación que sea) y lista para que alguien o algo la ejecute, es un programa. En nuestro caso, el "alguien o algo" que ejecuta el programa no es un cocinero, sino la CPU del ordenador, que es rapidísima pero extraordinariamente literal: hace exactamente lo que le dices, ni un paso más, ni uno menos.

La diferencia clave entre el cocinero humano y la CPU es que el humano improvisa, interpreta y corrige sobre la marcha; la CPU, no. Si en la receta pusieras "echa sal al gusto", un humano lo resuelve; una CPU se queda mirando al techo esperando una cantidad concreta.

Imagina que tienes un genio de la lámpara. Te concede cualquier deseo... pero es radicalmente literal. Si le pides "tráeme algo de beber", puede aparecer con un vaso de agua del grifo, zumo caducado o incluso agua de mar, porque técnicamente todo eso "es de beber". Nunca se equivoca en el sentido estricto de lo que le has pedido — se equivoca porque tú no has sido lo bastante preciso.

Programar es exactamente eso: aprender a hablarle a un genio (tu ordenador) que hace exactamente lo que le dices, ni una coma más ni una coma menos, convertir problemas humanos imprecisos en secuencias de instrucciones precisas.

Concepto	Definición formal	Analogía cocina	Características
Instrucción	Unidad mínima de orden que se da a un ejecutor	"Pela tres patatas"	Atómica, inequívoca, ejecutable
Algoritmo	Conjunto finito y ordenado de instrucciones que resuelven un problema	La receta completa en tu cabeza	Finito, determinista, termina
Programa	Algoritmo escrito en un lenguaje de programación concreto	La receta anotada en tu libreta	Ejecutable por una máquina

Lo importante del siguiente diagrama es que veas que el algoritmo es independiente del lenguaje (puedes describir los mismos pasos en español, en pseudocódigo o en Java), mientras que el programa ya está atado a un lenguaje concreto. A lo largo del curso vas a pasar de pensar algoritmos (lo difícil) a escribirlos en Java (lo mecánico, con práctica).

flowchart LR
    A["Problema real<br/>(ej. calcular media)"] --> B["Algoritmo<br/>(pasos en español)"]
    B --> C["Programa<br/>(algoritmo en Java)"]
    C --> D["Compilación<br/>javac"]
    D --> E["Bytecode<br/>.class"]
    E --> F["JVM<br/>(ejecución)"]
    F --> G["Resultado<br/>en pantalla"]
    style A fill: #fff3e0, stroke: #e65100, color: #000
    style B fill: #fff8e1, stroke: #f57f17, color: #000
    style C fill: #e3f2fd, stroke: #1565c0, color: #000
    style D fill: #f3e5f5, stroke: #6a1b9a, color: #000
    style E fill: #f3e5f5, stroke: #6a1b9a, color: #000
    style F fill: #e8f5e9, stroke: #2e7d32, color: #000
    style G fill: #e0f2f1, stroke: #00695c, color: #000

Diagrama 1.1 — Del problema real al resultado ejecutado: compilación y ejecución en Java.

Propiedades que todo algoritmo debe cumplir

No vale cualquier secuencia de pasos. Para que un conjunto de instrucciones merezca el nombre de algoritmo tiene que cumplir cinco propiedades. Guárdate esta tabla: cada vez que escribas un programa y algo falle, vuelve a ella y pregúntate cuál de las cinco has roto. El 80% de los bugs de principiante son fallos de "definido" (pasos ambiguos) o de "finito" (bucles que no terminan).

Propiedad	Qué significa	Qué pasa si no se cumple
Finito	Tiene un número limitado de pasos	Bucle infinito, programa que cuelga
Determinista	Mismas entradas producen mismas salidas	Resultados aleatorios, no reproducible
Definido	Cada paso es inequívoco	La CPU no sabe qué hacer
Entrada	Cero o más datos de entrada	No hay con qué trabajar
Salida	Al menos un resultado	El programa no sirve para nada

1.2 Historia y filosofía de Java: Write Once, Run Anywhere

De los electrodomésticos a los bancos

Java tiene una historia curiosa, casi contracultural. No nació para internet, ni para móviles, ni para bancos. Nació en 1991, dentro de Sun Microsystems, en un proyecto llamado Green Project cuyo objetivo era programar electrodomésticos y decodificadores de TV interactivos. James Gosling y su equipo crearon un lenguaje al que llamaron Oak ("roble", por el árbol que veían desde la ventana). El problema de los electrodomésticos es que cada uno tenía un procesador distinto, así que el lenguaje necesitaba no depender del hardware. Esa necesidad técnica accidental se convirtió, con los años, en su rasgo más revolucionario.

En 1995, ya rebautizado como Java (por el café de la isla de Java, de ahí el logo de la taza), el lenguaje aterrizó justo cuando la web empezaba a explotar. La promesa era tan atrevida que se convirtió en eslogan: Write Once, Run Anywhere (WORA, "escríbelo una vez, ejecútalo en cualquier sitio"). En una época en la que cada programa había que recompilar para Windows, Mac y Linux por separado, Java prometía compilar una sola vez y que el resultado corriera en cualquier ordenador con una JVM instalada.

Analogía

Imagina que existiera un idioma artificial, tipo esperanto pero bien hecho, que cualquier persona del mundo supiera leer. Tú escribirías tu novela una sola vez en ese idioma y cualquier lector, tu yo ruso, tu yo japonés o tu yo keniano, la entendería sin necesidad de traductores humanos. Java hace exactamente eso con los programas: tú escribes el código una vez, lo compilas una vez, y el archivo resultante (el bytecode) puede ejecutarse en cualquier sistema operativo que tenga instalada una JVM. La JVM es el "lector políglota" que aparece en cada país.

Esto, que hoy puede parecer normal porque Python, JavaScript o C# también puede correr en múltiples ordenadores, en 1995 era una pequeña revolución. Y explica por qué Java se coló en sitios donde otros lenguajes no llegaban: cajeros automáticos, tarjetas inteligentes, set-top boxes, routers y, más tarde, en cada móvil Android del planeta.

Año	Versión	Por qué importa
1991	(Oak)	Nace el proyecto Green en Sun Microsystems
1995	Java 1.0	Lanzamiento público; llega WORA y los applets
2004	Java 5	Generics, autoboxing, for-each: primer gran salto moderno
2014	Java 8	Lambdas y Streams API: Java se vuelve funcional
2017	Java 9	Sistema de módulos (JPMS); nuevo ritmo de versiones cada 6 meses
2021	Java 17 LTS	Records, sealed classes, pattern matching inicial
2023	Java 21 LTS	Virtual threads, pattern matching para switch
2025	Java 25 LTS	Versión que usaremos en este ciclo; soporte hasta 2030+

timeline
    title Hitos en la historia de Java
    1991: Proyecto Green (Sun Microsystems) - Lenguaje Oak
    1995: Renombrado a Java - Lanzamiento público
    1996: JDK 1.0 - Applets en navegador
    2004: Java 5 - Generics, autoboxing, for-each
    2014: Java 8 - Lambdas y Streams API
    2017: Java 9 - Sistema de módulos JPMS
    2018: Nuevo ritmo de releases - Versiones cada 6 meses
    2021: Java 17 LTS - Records, sealed, pattern matching
    2023: Java 21 LTS - Virtual threads, pattern matching final
    2025: Java 25 LTS - Soporte hasta 2030+

Diagrama 1.2 — Línea de tiempo de los hitos históricos de Java.

¿Por qué seguimos usando Java en la actualidad?

Te estarás preguntando: si Java tiene 30 años, ¿no estará obsoleto? La respuesta corta es que no, y la respuesta larga es que Java es uno de esos raros lenguajes que ha sabido modernizarse sin romper lo viejo. Tu código de Java 8 de 2014 sigue compilando en Java 25; pocas tecnologías pueden decir lo mismo. Además, el lenguaje ha incorporado en los últimos años características que lo hacen casi tan expresivo como Kotlin o Scala: records, sealed classes, pattern matching, inferencia de tipos con var, text blocks... Lo verás todo en su momento.

En el mercado laboral, Java es todavía el rey indiscutible en banca, seguros, administración pública y grande empresa. Si abres cualquier portal de empleo y buscas "programador Java" en Madrid, Barcelona, Valencia o Alicante, vas a encontrar miles de ofertas.

1.3 El código fuente, el código máquina y los niveles de abstracción

Antes de entrar de lleno en cómo funciona la máquina virtual de Java, necesitamos poner sobre la mesa tres conceptos que a veces se dan por sabidos: qué es el código fuente, qué es el código máquina y por qué hablamos de lenguajes de "alto" o "bajo" nivel.

El lenguaje de las máquinas vs. el lenguaje de los humanos

Un ordenador, en el fondo, es un montón de millones de interruptores diminutos (transistores) que solo pueden estar encendidos o apagados. Por tanto, el único idioma que la CPU (el cerebro del ordenador) entiende de forma nativa es el código máquina: secuencias interminables de ceros y unos (01001000 01101001).

Programar escribiendo ceros y unos, las tarjetas perforadas son un ejemplo, es infernal. Por eso, en los años 50, se inventó el ensamblador, un lenguaje de "bajo nivel" donde en lugar de ceros y unos escribes abreviaturas como ADD (sumar) o MOV (mover). Sin embargo, seguir programando en ensamblador es como construir un rascacielos ladrillo a ladrillo: tienes que decirle a la CPU exactamente en qué cajón de memoria guardar cada cosa. Además, cada modelo de procesador tiene su propio ensamblador.

Para resolver esto nacieron los lenguajes de alto nivel (como C, Python o Java). En un lenguaje de alto nivel, escribes instrucciones que se parecen mucho al inglés o a las matemáticas: if (saldo > 0) { pagarFactura(); }. Esto es el código fuente: el texto legible que tú y yo escribimos en nuestro editor.

Analogía: El menú del restaurante

Imagina que la CPU es un chef italiano muy testarudo que solo entiende recetas escritas en italiano y con cantidades exactas en gramos (código máquina).

Escribir en ensamblador (bajo nivel) sería como escribir la receta en italiano, pero pudiendo usar algunas abreviaturas.
Escribir en código fuente de alto nivel (Java, Python) sería como escribir la receta en español usando conceptos abstractos: "Haz una bechamel". Es mucho más fácil para ti, pero el chef no lo entiende. Necesitas un traductor que convierta tu "Haz una bechamel" en "Coge 50g de mantequilla, derrítela a fuego lento, añade 50g de harina...".

La diferencia principal entre los niveles es el grado de abstracción: a nivel más alto, menos te tienes que preocupar por los detalles del hardware (memoria, registros de la CPU) y más te puedes centrar en la lógica de tu programa.

Concepto	Qué es	¿Legible por humanos?	Ejemplo
Código fuente	El texto que escribe el programador.	Sí, está diseñado para que lo entiendas tú.	`int x = 5 + 3;`
Código máquina	Las instrucciones reales que ejecuta la CPU.	No, son números binarios.	`10110000 00000101 00000011`
Lenguaje de bajo nivel	Cerca del hardware (Ej. Ensamblador).	Difícil, pero posible. Depende de la CPU.	`MOV AL, 5` `ADD AL, 3`
Lenguaje de alto nivel	Cerca del humano. Abstrae el hardware.	Sí, muy legible. Multiplataforma (en teoría).	Java, Python, C++

El puente: la compilación y la interpretación

Como el ordenador no entiende tu código fuente de alto nivel, necesitamos un mecanismo que haga de traductor. Históricamente, hay dos formas de hacerlo:

Compilación: Un programa (el compilador) coge todo tu código fuente y lo traduce de golpe a código máquina, creando un archivo ejecutable (un .exe en Windows). Es como traducir y publicar un libro completo. El problema es que el código máquina resultante solo sirve para el sistema operativo y la CPU para los que se compiló. Si lo compilas para Windows, no correrá en un Mac.
Interpretación: Un programa (el intérprete) lee tu código fuente línea a línea y la va ejecutando al instante. No se crea un archivo traducido, es como tener un traductor simultáneo. Es más lento, pero el mismo código fuente puede correr en cualquier máquina que tenga ese intérprete.

Java, como verás en el siguiente punto, es un híbrido genial que toma lo mejor de ambos mundos para conseguir su promesa de Write Once, Run Anywhere.

1.4 La JVM: compilación a bytecode y ejecución multiplataforma

El doblaje de películas

Para entender cómo funciona Java por dentro, nada mejor que la analogía del doblaje. Imagina que ruedas una película en España y quieres que se vea en todo el mundo. Tienes dos opciones.

Doblarla tú mismo a 50 idiomas: necesitas un estudio de doblaje por cada país, volver a grabar la banda sonora cada vez, y si descubres un error en el montaje tienes que repetirlo en los 50 idiomas.
Escribir un guion neutral en un idioma "intermedio" y que cada país lo traduzca a su idioma local: trabajas una sola vez, y son los estudios locales los que se encargan del proceso final.

Java eligió la segunda opción. Cuando tú escribes Hola.java (el guion original, en código fuente Java) y lo compilas con javac, el resultado no es código máquina de Windows ni de Linux: es bytecode, un lenguaje intermedio neutral que guarda cierto parecido con el código fuente pero que ya no es legible para humanos. Ese bytecode es el "guion neutral" que viaja en el archivo Hola.class.

Después, en cada ordenador donde se quiera ejecutar, hay instalada una JVM (Java Virtual Machine), que es el "estudio de doblaje local". La JVM lee el bytecode y, sobre la marcha, lo traduce al código máquina específico de esa CPU y ese sistema operativo. Esa traducción al vuelo la hace un componente llamado JIT (Just-In-Time compiler), que además va optimizando las partes del código que se ejecutan más veces.

flowchart TD
    SRC["Hola.java<br/>(código fuente)"] -->|javac| BC["Hola.class<br/>(bytecode)"]
    BC --> JVM["JVM de Windows"]
    BC --> JVM2["JVM de Linux"]
    BC --> JVM3["JVM de macOS"]
    JVM --> NAT["Código máquina x86"]
    JVM2 --> NAT2["Código máquina ARM/Linux"]
    JVM3 --> NAT3["Código máquina Apple Silicon"]
    style SRC fill: #e3f2fd, stroke: #1565c0, color: #000
    style BC fill: #f3e5f5, stroke: #6a1b9a, color: #000
    style JVM fill: #e8f5e9, stroke: #2e7d32, color: #000
    style JVM2 fill: #e8f5e9, stroke: #2e7d32, color: #000
    style JVM3 fill: #e8f5e9, stroke: #2e7d32, color: #000
    style NAT fill: #ffebee, stroke: #c62828, color: #000
    style NAT2 fill: #ffebee, stroke: #c62828, color: #000
    style NAT3 fill: #ffebee, stroke: #c62828, color: #000

Diagrama 1.3 — Compilación Java y ejecución multiplataforma: el mismo .class se ejecuta en tres sistemas operativos distintos.

Fíjate en lo importante: el archivo .class es el mismo en las tres ramas del diagrama. No hay tres compilaciones distintas, hay tres ejecuciones distintas. Ahí es donde se cumple la promesa WORA.

Compilados, interpretados e híbridos: dónde encaja Java

Modelo	Ejemplos	Flujo	Ventajas	Inconvenientes
Compilado puro	C, C++, Rust	Fuente → código máquina nativo	Máximo rendimiento	Recompilar para cada plataforma
Interpretado puro	Python, JavaScript (tradicional)	Fuente → intérprete → ejecución	Sencillo y multiplataforma	Más lento; fuente se reparte
Híbrido (Java, C#)	Java, Kotlin, C#	Fuente → bytecode → VM → nativo (JIT)	Multiplataforma real + buen rendimiento	Necesita la VM instalada; arranque algo más lento

Java es, técnicamente, un lenguaje compilado a un intermediario e interpretado por una máquina virtual, con un compilador JIT que le da un rendimiento cercano al código nativo. Esta combinación es la que ha hecho de Java un lenguaje equilibrado: lo bastante rápido para un banco, lo bastante portable para un móvil Android.

¿Qué es exactamente el bytecode?

El bytecode es un conjunto de instrucciones para una CPU que no existe físicamente: la CPU "virtual" que define la especificación de Java. Cada instrucción de bytecode (llamada opcode) ocupa uno o pocos bytes, de ahí el nombre. Si abres un .class con un visor hexadecimal verás un galimatías; si lo abres con javap -c Hola.class verás algo legible que se parece a un ensamblador abstracto:

0: iconst_1        // apilar el entero 1
1: istore_1        // guardarlo en la variable local 1
2: iload_1         // cargar la variable local 1
3: iinc 1, 1       // incrementar la variable local 1 en 1

No te asustes: tú nunca vas a escribir bytecode a mano. Pero conviene saber que existe, porque cuando depures programas complejos verás stack traces que hablan de "bytecode" y de "métodos compilados por el JIT", y conviene no pensar que es magia.

1.5 Java 25 LTS en el mercado laboral: por qué este lenguaje

Analogía

Si los lenguajes de programación fueran vehículos, Python sería un coche eléctrico moderno, cómodo y de moda; JavaScript sería una furgoneta camper llena de pegatinas; Rust sería un coche de carreras con cinturones de cinco puntos; y Java sería una furgoneta de empresa, de esas que llevan 400.000 km sin fallar, con taller en cualquier pueblo y piezas baratas. No es la más bonita ni la más rápida, pero es la que te va a llevar al trabajo todos los días durante años sin dejarte tirado. Por eso las empresas la eligen para sus sistemas críticos: porque el riesgo de que "Java desaparezca" es bajísimo.

Que Java sea un LTS (Long Term Support) significa que esa versión específica va a recibir actualizaciones de seguridad y arreglos de bugs durante muchos años, no solo seis meses como las versiones intermedias. Para una empresa que tiene 200 millones de líneas de código en producción, migrar de versión es carísimo; por eso solo se mueve a una LTS nueva cada 2 o 3 años, y entre medias se queda quieta.

Java 25 concretamente

Java 25 se publicó en septiembre de 2025 y es la LTS que vamos a usar durante todo el ciclo. ¿Por qué Java 25 y no Java 21 (la LTS anterior, de 2023)? Por varias razones que irás entendiendo a lo largo del curso:

Característica moderna	Disponible desde	Te afecta en
var (inferencia de tipos)	Java 10 (2018)	UD1 — desde el primer día
Text blocks `"""..."""`	Java 15 (2020)	UD1 — cadenas multilínea
Records	Java 16 (2021)	UD4 — clases inmutables
Sealed classes	Java 17 (2021)	UD7 — jerarquías cerradas
Pattern matching para switch	Java 21 (2023)	UD3 — selección moderna
Virtual threads	Java 21 (2023)	UD8 — concurrencia ligera
Implicitly declared classes + instance main (estable, JEP 512)	Java 25 (2025)	UD1 — `void main()` sin clase ni `static`

Especialmente interesante para empezar es esa última fila. Históricamente, tu primer programa en Java era un pequeño horror de cinco líneas solo para imprimir "Hola":

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

En Java 25 ya puedes escribir, de forma estable, exactamente lo mismo con mucha menos ceremonia:

void main() {
    System.out.println("Hola");
}

Sin public class, sin static, sin String[] args. Menos ceremonia, mismo resultado. A lo largo de UD1 empezaremos con la forma moderna y, cuando toque, iremos explicando qué era todo eso que ya no tienes que escribir.

¿Dónde se usa Java hoy?

Sector	Ejemplos reales
Banca y seguros	BBVA, Santander, Mapfre — backoffice y pasarelas de pago
Administración pública	Seguridad Social, Hacienda, Catastro — muchas intranets
Telecomunicaciones	Orange, Vodafone — sistemas de facturación
Android	Toda la app nativa no-Kotlin sigue siendo Java
Big Data	Hadoop, Spark, Kafka, ElasticSearch — escritos en Java o JVM
E-commerce	MercadoLibre, parte de Amazon — backends masivos
IoT y embebido	Tarjetas inteligentes, SIM, set-top boxes

Si alguna vez te preguntan "¿y esto para qué sirve?", tienes ahí la respuesta: para casi todo lo que mueve dinero, datos y servicios a escala industrial.

1.6 Diferencia entre JDK, JRE y JVM

Motor, coche y taller

Tres siglas que se parecen y que todo el mundo confunde al principio. Vamos con la analogía definitiva.

La JVM es el motor del coche. Es la pieza que realmente hace que el vehículo se mueva, pero por sí sola no sirve para nada: un motor en el suelo no te lleva a ninguna parte. En Java, la JVM es la máquina virtual, el software que interpreta el bytecode y lo convierte en código máquina. Existe una JVM distinta para cada sistema operativo (la de Windows, la de Linux, la de macOS), pero todas entienden el mismo bytecode.

El JRE (Java Runtime Environment) es el coche completo listo para conducir: motor (JVM) + ruedas + volante + asientos. Es decir, la JVM más las librerías estándar de Java (java.base, java.util, java.io, etc.) que necesitan los programas para funcionar. Si solo quieres ejecutar programas Java que otra persona ha escrito, con el JRE te basta. Es lo que instalarías, por ejemplo, para correr Minecraft en su día.

El JDK (Java Development Kit) es el taller completo con herramientas, repuestos y manuales: coche (JRE) + gato + llaves + manual de instrucciones + piezas de recambio. Es decir, el JRE más todas las herramientas de desarrollo: el compilador javac, el depurador jdb, la consola interactiva jshell, el generador de documentación javadoc, el empaquetador jar, etc. Si lo que quieres es desarrollar (escribir y compilar) programas Java, lo que necesitas instalar es el JDK. Como desarrolladores que sois, en este ciclo instalaremos siempre el JDK.

	JVM	JRE	JDK
Qué es	Máquina virtual	Entorno de ejecución	Kit de desarrollo
Para qué sirve	Interpretar bytecode	Ejecutar programas Java	Desarrollar y ejecutar
Incluye JVM	(es la propia)	Sí	Sí
Incluye librerías std	No	Sí	Sí
Incluye herramientas dev	No	No	Sí (`javac`, `jshell`, `jdb`...)
Lo instala	—	Un usuario final	Un programador
Analogía	Motor	Coche	Taller completo
¿Lo instalamos?	—	—	Sí (Adoptium Temurin 25)

flowchart TD
    JDK["JDK<br/>Java Development Kit<br/>(para DESARROLLAR)"]
    JDK --> JRE["JRE<br/>Java Runtime Environment<br/>(para EJECUTAR)"]
    JRE --> JVM["JVM<br/>Java Virtual Machine<br/>(para INTERPRETAR bytecode)"]
    JDK -.->|además incluye| TOOLS["javac, jdb, jshell,<br/>javadoc, jar, etc."]
    JRE -.->|además incluye| LIBS["java.base, java.util,<br/>java.io"]
    JVM -.->|hace| EXEC["Interpreta bytecode<br/>+ JIT a código máquina"]
    style JDK fill: #1565c0, color: #fff, stroke: #0d47a1
    style JRE fill: #2e7d32, color: #fff, stroke: #1b5e20
    style JVM fill: #e65100, color: #fff, stroke: #bf360c
    style TOOLS fill: #e3f2fd, stroke: #1565c0, color: #000
    style LIBS fill: #e8f5e9, stroke: #2e7d32, color: #000
    style EXEC fill: #fff3e0, stroke: #e65100, color: #000

Diagrama 1.4 — Relación de inclusión JDK ⊃ JRE ⊃ JVM y herramientas asociadas.

Un detalle importante para 2026

Tradicionalmente, el JDK incluía el JRE como subconjunto y, al instalar Java, tenías ambas cosas. A partir de Java 11, el JRE ya no se distribuye como paquete independiente para uso general; los desarrolladores instalamos directamente el JDK y, para ejecutar aplicaciones, se usan "runtime images" creadas con jlink o simplemente el propio JDK. Por eso, cuando en la Sección 2 instales Java 25, instalarás un JDK completo (Adoptium Temurin 25) y no te preocuparás más por el JRE. La distinción te la explico ahora porque la encontrarás en manuales antiguos, en preguntas de examen y en charlas con compañeros de otros lenguajes, pero en la práctica diaria con Java moderno queda reducida a "instalas el JDK y a correr".

La familia de herramientas del JDK que más usarás

Herramienta	Para qué sirve	Cuándo la usas
javac	Compilador: `.java` → `.class`	Cada vez que compilas
java	Lanzador de la JVM que ejecuta `.class`	Cada vez que ejecutas
jshell	Consola interactiva REPL	Para probar expresiones sueltas
javadoc	Genera documentación HTML a partir de comentarios	Cuando documentas tu API
jar	Empaqueta `.class` en un archivo `.jar`	Cuando distribuyes tu app
jdb	Depurador en línea de comandos	Cuando algo falla y no tienes IDE
jlink	Crea runtime images personalizadas	Para despliegues ligeros

En la Sección 2 verás que IntelliJ IDEA te oculta casi todo esto con botones y atajos, pero conviene saber qué hay por debajo, porque el día que algo falle en el IDE tendrás que bajar a la consola y llamar a javac o java a mano.

Resumen de la sección 1

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

Programar es convertir un problema humano en una secuencia de instrucciones precisas que una CPU puede ejecutar. Esa secuencia, si es finita y determinista, se llama algoritmo; cuando se escribe en un lenguaje concreto, se llama programa.
Java nació en 1991 para electrodomésticos, se publicó en 1995 y lleva 30 años modernizándose sin romper compatibilidad. Su filosofía WORA (Write Once, Run Anywhere) es la razón de su éxito multiplataforma.
La JVM es la pieza que cumple la promesa WORA: ejecuta el mismo bytecode en cualquier sistema operativo, traduciéndolo al vuelo a código máquina nativo gracias al compilador JIT.
Java 25 LTS (septiembre 2025) es la versión que usaremos, con soporte hasta 2030. Incorpora mejoras modernas (var, text blocks, records, pattern matching, virtual threads, implicitly declared classes) que hacen el código más limpio que nunca.
JVM, JRE y JDK son tres niveles: la JVM interpreta bytecode, el JRE añade librerías para ejecutar, el JDK añade herramientas para desarrollar. En Java moderno solo instalamos el JDK.

Próximos pasos y checkpoint

En la Sección 2 pondremos las manos en el teclado: instalaremos JDK 25 e IntelliJ IDEA, crearemos nuestro primer proyecto Maven y verás por qué el pom.xml no es un documento de miedo sino tu mejor amigo.