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

Ficha de la sección

Campo	Valor
Unidad de Programación	UD1 — Fundamentos de Programación
Resultado de Aprendizaje	RA1 — Reconoce la estructura de un programa informático, identificando y relacionando los elementos propios del lenguaje de programación utilizado
Duración orientativa	Aproximadamente 3 de las 28 horas totales de UD1
Criterios de Evaluación implicados	Esta sección es la base conceptual de todo RA1. Prepara directamente el terreno para CE 1.1 (bloques de un programa) y CE 1.3 (entornos integrados de desarrollo), que se trabajarán en profundidad en los puntos 2 y 3 de esta misma unidad. El resto de CE de RA1 (variables, constantes, operadores, conversión de tipos) llegan más adelante en UD1
Encaja en el roadmap	Es el primer contacto del ciclo con la programación. Todo lo que viene después (UD2 a UD9) da por hecho que entiendes qué es la JVM, por qué existe el bytecode y qué diferencia hay entre JDK y JRE

Antes de empezar

Vas a pasar los próximos dos años escuchando la palabra "Java" varias veces al día. Antes de escribir ni una sola línea de código, merece la pena que entiendas qué estás haciendo realmente cuando programas, por qué existe Java y qué ocurre por dentro cuando ejecutas un programa. Esto no es relleno teórico: es la diferencia entre memorizar órdenes sin sentido y entender por qué esas órdenes funcionan como funcionan. Cuando dentro de unas semanas te salga un error raro en IntelliJ, vas a agradecer haber leído esto.

Vamos por partes.

1.1. ¿Qué es programar?

Programar es, en esencia, dar instrucciones a un ordenador para que resuelva un problema, con un matiz importante: el ordenador es literal hasta el extremo. No intuye, no rellena huecos, no "más o menos entiende lo que querías decir". Si le faltas un detalle, no lo intenta adivinar como haría un compañero de clase: falla, o hace exactamente lo que le has dicho, aunque sea absurdo.

Piensa en la última vez que le explicaste a alguien cómo llegar a tu casa. Seguramente dijiste algo como "sigue todo recto y luego giras donde está el bar". Un ser humano rellena ese "donde está el bar" con sentido común. Un ordenador no. Un ordenador necesita algo más parecido a:

Camina 200 metros. Al llegar al cruce con el semáforo, gira a la derecha. Continúa 150 metros. La tercera puerta a tu izquierda es la entrada.

Esa precisión incómoda, esa necesidad de no dejarte nada en el tintero, es la esencia de programar. Por eso el primer cambio de chip que vas a tener que hacer no es aprender sintaxis: es aprender a pensar en pasos exactos, ordenados y sin ambigüedad.

	Instrucción para una persona	Instrucción para un ordenador
Ambigüedad	Se tolera, el humano interpreta	Cero tolerancia, se ejecuta tal cual
Orden	Flexible, se puede intuir	Estrictamente secuencial salvo que se indique lo contrario
Casos raros ("¿y si no hay bar?")	Se resuelven sobre la marcha	Hay que preverlos explícitamente o el programa falla
Repetición de tareas	Nos aburre, la evitamos	No le afecta, la hace con precisión mecánica

Nota para el aula. Esta "obediencia ciega" del ordenador es en realidad su mayor virtud, no su defecto. Un ordenador nunca se salta un paso por pereza ni comete un error por despiste; si algo falla, el fallo está en las instrucciones que le diste, no en su ejecución. Acostúmbrate a esta idea, porque el 90% de la depuración de código consiste en aceptar que el error es tuyo, no del ordenador.

1.2. Programa, algoritmo e instrucción: la anatomía de tu primer proyecto

Estos tres términos se usan a veces como sinónimos en el lenguaje coloquial, pero en programación tienen un significado preciso y jerárquico. Vamos a fijarlo con una imagen que no se te va a olvidar: un recetario de cocina.

Un recetario (el libro completo) es tu programa: una colección de soluciones a distintos problemas, organizada y pensada para usarse de forma conjunta.
Cada receta individual dentro del recetario es un algoritmo: una secuencia finita y ordenada de pasos que resuelve un problema concreto ("cómo hacer una tortilla de patatas").
Cada paso numerado dentro de esa receta es una instrucción: la unidad mínima de acción ("bate los huevos", "añade sal").

Concepto	Definición	Analogía (recetario)	Ejemplo en un programa de gestión de notas
Programa	Conjunto completo de algoritmos e instrucciones que, trabajando juntos, resuelven un problema real	El recetario entero	Una aplicación que gestiona las notas de un ciclo formativo
Algoritmo	Secuencia finita, ordenada y no ambigua de pasos que resuelve un problema concreto	Una receta concreta ("tortilla de patatas")	El proceso completo para "calcular la nota media de un alumno"
Instrucción	La orden mínima y ejecutable dentro de un algoritmo	Un paso de la receta ("bate los huevos")	"Suma las notas", "divide entre el número de notas"

flowchart TD
    P["**PROGRAMA**\nGestor de Notas del Ciclo"] --> A1["**ALGORITMO**\nCalcular la nota media"]
    P --> A2["**ALGORITMO**\nComprobar si el alumno aprueba"]
    P --> A3["**ALGORITMO**\nMostrar el boletín de notas"]
    A1 --> I1["Instrucción\nLeer las notas introducidas"]
    A1 --> I2["Instrucción\nSumar todas las notas"]
    A1 --> I3["Instrucción\nDividir la suma entre el nº de notas"]

    style P fill:#1565c0,color:#fff,stroke:#0d47a1
    style A1 fill:#2e7d32,color:#fff,stroke:#1b5e20
    style A2 fill:#2e7d32,color:#fff,stroke:#1b5e20
    style A3 fill:#2e7d32,color:#fff,stroke:#1b5e20

Un buen algoritmo cumple siempre tres propiedades, que conviene memorizar porque te las van a preguntar en la prueba objetiva de RA1:

Finitud: tiene que terminar en algún momento. Un algoritmo que nunca acaba no es un algoritmo, es un bucle infinito (que, por cierto, veremos en UD3 y a veces será un error, y a veces intencionado).
Precisión (no ambigüedad): cada paso debe estar completamente definido, sin margen de interpretación.
Orden: los pasos se ejecutan en una secuencia determinada, salvo que el propio algoritmo indique explícitamente lo contrario (esto es justo lo que hacen las estructuras de control que verás en UD3: decidir cuándo el orden "normal" se altera).

Dato clave. Fíjate en que hasta este punto no hemos escrito ni una línea de Java. Y es intencionado: un algoritmo no depende del lenguaje de programación. Podrías describir "calcular la nota media" en español, en pseudocódigo, en un diagrama de flujo o en Java, y seguiría siendo el mismo algoritmo. El lenguaje de programación es solo el idioma que elegimos para comunicárselo al ordenador. En este módulo, ese idioma va a ser Java 25 LTS.

1.3. Historia y filosofía de Java: "Write Once, Run Anywhere"

Un poco de historia (la mínima imprescindible, pero útil)

Java nace en 1991 dentro de Sun Microsystems, en un proyecto liderado por James Gosling, con un objetivo que hoy nos resulta casi anecdótico: programar electrodomésticos y dispositivos empotrados (set-top boxes, básicamente). El problema que tenían era muy concreto: cada fabricante de hardware tenía su propio procesador, y el mismo programa en C no funcionaba igual en todos ellos sin recompilarlo y, a menudo, sin reescribir partes enteras.

El proyecto original (llamado "Oak", por un roble que había junto a la oficina de Gosling) evolucionó, y en 1995 se relanzó públicamente como Java, aprovechando la explosión de Internet como el escenario perfecto para su idea central: un mismo programa que se ejecuta igual en cualquier ordenador, sin importar el sistema operativo ni el hardware.

Mito frecuente. "Java y JavaScript son básicamente lo mismo, uno es la versión reducida del otro." Falso, y es uno de los mitos más repetidos de la informática. Comparten parte del nombre por una decisión puramente comercial de 1995: JavaScript (creado por Netscape) se llamaba originalmente "LiveScript", y se rebautizó para subirse a la ola de popularidad que tenía Java en ese momento. Son lenguajes distintos, con sintaxis, propósito y forma de ejecutarse completamente diferentes. Es como comparar "carro" y "carroza": comparten letras, no comparten esencia.

La filosofía WORA: "Write Once, Run Anywhere"

El eslogan que resume la razón de ser de Java es "Write Once, Run Anywhere" ("escribe una vez, ejecuta en cualquier lugar"), y no es marketing vacío: es literalmente la arquitectura técnica del lenguaje.

Imagina que compones una partitura musical. Si la escribes en notación musical estándar, cualquier músico cualificado la puede interpretar, sea cual sea su instrumento: un piano, un violín o una guitarra "leen" la misma partitura y producen música, aunque el mecanismo físico de cada instrumento sea distinto. Java funciona con una lógica parecida: tu código fuente se traduce a un formato intermedio universal (el bytecode), y cada sistema operativo tiene su propio "intérprete" capaz de leer ese bytecode y convertirlo en las instrucciones nativas que su procesador entiende. Ese intérprete es la JVM, y es el tema del siguiente apartado.

La alternativa clásica (lenguajes como C o C++) compila el código fuente directamente a instrucciones específicas del procesador y del sistema operativo de destino. Eso significa que si quieres que tu programa funcione en Windows, macOS y Linux, necesitas compilarlo tres veces, una por cada sistema, y a veces incluso adaptar parte del código. Java se ahorra ese problema gracias a esa capa intermedia.

	Lenguajes compilados a nativo (C, C++...)	Java
¿Qué genera el compilador?	Código máquina específico del procesador y SO de destino	Bytecode universal (`.class`)
¿Cuántas veces hay que compilar para varios SO?	Una por cada combinación de SO/procesador	Una única vez
¿Quién ejecuta el resultado?	El sistema operativo directamente	La JVM, instalada en cada sistema
Coste de "portar" a otro SO	Alto: recompilar, a veces reescribir	Prácticamente nulo

1.4. La JVM: de tu código a bytecode, y de bytecode a cualquier sistema operativo

Vamos a desmontar el proceso completo, paso a paso, porque esto es algo que te van a preguntar de mil formas distintas a lo largo del curso.

Escribes tu código fuente en un fichero de texto con extensión .java.
El compilador de Java (una herramienta llamada javac, que instalarás en la Sección 2) traduce ese código fuente a bytecode, un conjunto de instrucciones intermedias que se guardan en un fichero .class. Este bytecode no es código máquina real de ningún procesador concreto: es un formato inventado por Java, pensado para ser interpretado.
La JVM (Java Virtual Machine), instalada en el ordenador donde quieras ejecutar el programa, lee ese bytecode y lo traduce, sobre la marcha, a las instrucciones nativas que ese procesador y ese sistema operativo concretos sí entienden.

flowchart LR
    S["Código fuente\nMain.java"] -->|"javac (compilador)"| B["Bytecode\nMain.class"]
    B --> JW["JVM\nWindows"]
    B --> JL["JVM\nLinux"]
    B --> JM["JVM\nmacOS"]
    JW --> RW["Se ejecuta\nen Windows"]
    JL --> RL["Se ejecuta\nen Linux"]
    JM --> RM["Se ejecuta\nen macOS"]

    style S fill:#e65100,color:#fff,stroke:#bf360c
    style B fill:#1976d2,color:#fff,stroke:#0d47a1
    style JW fill:#6a1b9a,color:#fff,stroke:#4a148c
    style JL fill:#6a1b9a,color:#fff,stroke:#4a148c
    style JM fill:#6a1b9a,color:#fff,stroke:#4a148c

Fíjate en el detalle clave: compilas una vez (generas un único .class) y ese mismo fichero se puede llevar a un Windows, a un Linux o a un Mac, y funcionará igual en los tres, siempre que cada uno tenga su JVM instalada. La JVM es la que "sabe" adaptarse a cada sistema operativo y a cada procesador; tú, como programador, no tienes que preocuparte por esa parte.

Dato clave para no perderse. La JVM moderna (incluida la de Java 25) no se limita a "traducir línea a línea" el bytecode de forma lenta. Incorpora un componente llamado JIT (Just-In-Time compiler) que detecta qué partes del programa se ejecutan muchas veces y las compila a código máquina real de forma optimizada mientras el programa está corriendo. Gracias a esto, el rendimiento de Java en 2026 está muy lejos de la imagen de "lenguaje lento" que a veces todavía se arrastra de los años 90. No profundizaremos en el JIT en este módulo, pero es bueno que sepas que existe.

Como pequeño adelanto de lo que verás en la Sección 3 (todavía no necesitas entender la sintaxis en detalle), así es como se ve el fichero fuente que da lugar a ese bytecode:

package dam.programacion.ud1;

// Este mismo fichero, una vez compilado a Main.class,
// se ejecuta igual en Windows, en Linux y en macOS.
// No te preocupes ahora por la sintaxis: la explicaremos
// paso a paso en la Sección 3 de esta unidad.
public class HolaMundo {
    public static void main(String[] args) {
        System.out.println("Hola, DAM. Esto se ejecuta en cualquier sistema operativo.");
    }
}

1.5. JDK, JRE y JVM: quién es quién

Estas tres siglas se confunden constantemente, incluso entre profesionales con experiencia, así que vamos a fijarlas de forma definitiva con otra analogía: un estudio de grabación musical.

La JVM es el motor de reproducción: el componente que de verdad interpreta y ejecuta el bytecode. Sin JVM no hay ejecución posible, sea cual sea el sistema operativo.
El JRE (Java Runtime Environment) es la JVM más las bibliotecas estándar que cualquier programa Java necesita para funcionar (las clases básicas de java.lang, java.util, java.io, etc., que irás conociendo a lo largo del curso). El JRE es lo mínimo que necesita un usuario final que solo quiere ejecutar una aplicación Java ya hecha, sin tocar código.
El JDK (Java Development Kit) es el JRE más las herramientas de desarrollo: el compilador (javac), el generador de documentación (javadoc), herramientas de depuración, el REPL interactivo (jshell), y mucho más. El JDK es lo que necesita quien programa, es decir, tú a partir de ahora.

flowchart TB
    subgraph JDK["JDK — Java Development Kit (para programar)"]
        direction TB
        HERR["Herramientas de desarrollo\njavac · javadoc · jar · jshell · depurador"]
        subgraph JRE["JRE — Java Runtime Environment (para ejecutar)"]
            direction TB
            LIBS["Bibliotecas estándar\njava.lang · java.util · java.io ..."]
            JVM["JVM — Java Virtual Machine\nel motor que interpreta el bytecode"]
        end
    end

    style JDK fill:#e3f2fd,stroke:#5B93D2
    style JRE fill:#e8f5e9,stroke:#81B184
    style JVM fill:#B48DCC,color:#fff,stroke:#4a148c
    style HERR fill:#5B93D2,color:#fff,stroke:#0d47a1
    style LIBS fill:#81B184,color:#fff,stroke:#1b5e20

Componente	Nombre completo	Qué es	Para quién es	Analogía
JVM	Java Virtual Machine	El motor que interpreta y ejecuta el bytecode	Imprescindible en cualquier máquina donde se ejecute Java	El motor de un reproductor que decodifica el audio
JRE	Java Runtime Environment	JVM + bibliotecas estándar necesarias para ejecutar programas ya compilados	Un usuario final que solo quiere ejecutar una aplicación Java	El reproductor completo, con altavoces incluidos
JDK	Java Development Kit	JRE + herramientas para programar (compilador, depurador, generador de documentación...)	El desarrollador: tú, desde este mismo curso	El estudio de grabación completo: compones, grabas y también puedes reproducir

Dato clave y actualizado. Hasta Java 8, era habitual instalar el JRE de forma independiente si solo querías ejecutar programas Java, y el JDK aparte si además querías programarlos. Desde Java 11 (2018), Oracle dejó de distribuir un JRE público independiente: hoy, cuando instalas un JDK (en nuestro caso, Adoptium Temurin 25, la distribución que usaremos en este módulo), ya tienes dentro todo lo necesario tanto para programar como para ejecutar. Para quien solo necesita ejecutar aplicaciones en producción y quiere algo más ligero, existe una herramienta llamada jlink que permite construir un runtime a medida, recortando lo que no se necesita; es un tema avanzado que retomaremos más adelante en el curso, no te preocupes por ello ahora.

1.6. Java 25 LTS en el mercado laboral: por qué este lenguaje (y no otro)

¿Qué significa "LTS"?

LTS son las siglas de Long Term Support (soporte a largo plazo). Java saca una versión nueva cada seis meses, pero solo algunas de ellas reciben el sello LTS, que implica que Oracle y el resto de proveedores del ecosistema (Adoptium, Amazon Corretto, Azul, etc.) mantendrán actualizaciones de seguridad y correcciones durante varios años. Esto es exactamente lo que buscan las empresas: una versión estable sobre la que construir software que va a vivir en producción durante mucho tiempo, sin tener que estar migrando cada seis meses.

Versión	Año de lanzamiento	Tipo	Novedades más destacadas
Java 8	2014	LTS	Expresiones lambda y Streams API: el cambio más grande de la historia del lenguaje hasta la fecha
Java 11	2018	LTS	`var` para inferencia de tipos, nuevo cliente HTTP, fin del JRE independiente
Java 17	2021	LTS	Sealed classes, pattern matching básico, records ya estables
Java 21	2023	LTS	Pattern matching avanzado con deconstrucción de records, virtual threads
Java 25	2025	LTS (la que usamos este curso)	Pattern matching completo, unnamed classes e instance main methods, Stream Gatherers estables

Este módulo se apoya en Java 25 LTS precisamente por ser la versión más reciente con soporte extendido: aprenderás la sintaxis moderna del lenguaje (la que verás en ofertas de trabajo reales publicadas a partir de 2026), sin dejar de estar preparado para trabajar sobre el código heredado en Java 8, 11 o 17 que te vas a encontrar en la mayoría de empresas, porque las bases del lenguaje no cambian.

Java en el mundo real: más presente de lo que imaginas

Producto o sector	Presencia de Java
Minecraft (edición Java)	El videojuego original, el que dio origen a todos los demás, está escrito íntegramente en Java
Banca y seguros	Los sistemas centrales ("core banking") de buena parte de la banca y las aseguradoras que operan en España llevan décadas construidos y mantenidos en Java
Administración pública	Gran parte del software de gestión de las administraciones españolas se apoya en Java
Big Data	Herramientas de referencia como Apache Kafka, Hadoop o Elasticsearch están escritas en Java o en otros lenguajes que corren sobre la JVM
Android (histórico)	Java fue durante años el lenguaje principal de desarrollo Android; hoy convive con Kotlin, un lenguaje que comparte máquina virtual y buena parte de su filosofía
Backend empresarial	Frameworks como Spring Boot son, hoy en día, uno de los estándares de facto para construir el backend de aplicaciones web y APIs en todo el mundo

Por qué te interesa esto como estudiante de DAM. No aprendes Java como un ejercicio académico aislado: aprendes Java porque es una de las apuestas más seguras si buscas estabilidad laboral a medio y largo plazo. Es un lenguaje maduro, con una comunidad enorme, con soporte empresarial garantizado durante años gracias al modelo LTS, y con una demanda que rara vez depende de modas pasajeras. Aprenderlo bien desde los fundamentos (que es justo lo que vamos a hacer en esta unidad) es una inversión que te va a acompañar durante toda tu carrera profesional, uses después el lenguaje que uses.

Resumen de la sección

Idea clave	En una frase
Programar	Dar instrucciones exactas, ordenadas y sin ambigüedad a un ordenador
Programa / Algoritmo / Instrucción	Recetario / receta / paso de la receta: tres niveles de una misma jerarquía
Write Once, Run Anywhere	Compilas una vez a bytecode; cualquier sistema con JVM lo ejecuta sin recompilar
JVM	El motor que interpreta el bytecode y lo adapta a cada sistema operativo
JDK / JRE / JVM	Desarrollar (JDK) contiene a ejecutar (JRE), que contiene al motor (JVM)
Java 25 LTS	Versión moderna con soporte a largo plazo, la que usa la industria y la que usaremos en este módulo

Comprueba lo que has entendido

Antes de pasar a instalar herramientas en la Sección 2, resuelve mentalmente (o en tu cuaderno) estas cuatro preguntas. Si alguna te cuesta, vuelve al apartado correspondiente antes de continuar:

Si un algoritmo es como una receta de cocina, ¿qué sería, siguiendo esa misma analogía, una única instrucción?
¿Por qué un programa Java compilado en tu ordenador con Windows puede ejecutarse sin volver a compilarlo en el ordenador Linux de un compañero?
Ordena de "más pequeño" a "más grande" estos tres conceptos, en el sentido de qué contiene a qué: JDK, JVM, JRE.
¿Qué papel juega el javac en todo este proceso, y en qué se diferencia de la JVM?

Qué viene ahora

Esta sección ha sido puramente conceptual: no hemos instalado nada ni escrito un programa real todavía. En la Sección 2 de UD1 vas a instalar el JDK 25 (Adoptium Temurin), configurar IntelliJ IDEA Community y crear tu primer proyecto Maven, poniendo en práctica de forma tangible todo lo que aquí has entendido en teoría: verás en tu propia pantalla cómo javac genera un .class y cómo la JVM lo ejecuta.