Módulo 00: Introducción a la programación y a Java

Objetivos del módulo

  • Entender cómo es un ordenador desde el punto de vista de quien programa: CPU, memoria, almacenamiento y dispositivos de entrada/salida
  • Saber qué son un programa, un algoritmo y un lenguaje de programación
  • Distinguir los niveles de lenguaje: código máquina, ensamblador y alto nivel
  • Comprender la diferencia entre compilar, interpretar y la compilación JIT
  • Conocer los grandes paradigmas de programación
  • Repasar la historia de Java y su modelo de versiones (cadencia semestral y versiones LTS)
  • Entender las piezas de la plataforma Java: JVM, bytecode, JRE y JDK
  • Conocer las principales distribuciones del JDK y dónde se usa Java hoy
  • Conocer las fases del ciclo de vida del desarrollo de un programa

1. ¿Por qué aprender a programar?

Programar es dar instrucciones a un ordenador para que resuelva un problema por nosotros. Detrás de cada aplicación que usas a diario (el móvil, el banco, los videojuegos, la web del instituto o la universidad) hay personas que han escrito esas instrucciones.

Aprender a programar no consiste en memorizar un lenguaje, sino en aprender a pensar de forma ordenada:

  • Descomponer un problema grande en problemas pequeños.
  • Describir con precisión, paso a paso, cómo se resuelve cada uno.
  • Comprobar que la solución funciona en todos los casos, también en los raros.
  • Expresar esa solución en un lenguaje que el ordenador pueda ejecutar.

📘 Concepto: Un ordenador es una máquina muy rápida pero completamente literal: hace exactamente lo que le dices, ni más ni menos, aunque lo que le digas no tenga sentido. Programar es aprender a decirle las cosas con total precisión.

En este curso usaremos Java, uno de los lenguajes más utilizados del mundo en empresas, administraciones públicas y universidades. Es el lenguaje del módulo de Programación de los ciclos de DAM y DAW y el de muchas asignaturas de primer curso de los grados de Informática.

💡 Consejo: No te agobies si al principio todo parece muy abstracto. En este módulo no vas a escribir casi código: vas a construir el mapa mental que necesitas para entender lo que ocurre cuando, en el módulo 01, escribas y ejecutes tu primer programa.

2. El ordenador visto por un programador

No necesitas saber electrónica para programar, pero sí conocer las cuatro piezas con las que trabaja todo programa.

Arquitectura de von Neumann: CPU, memoria principal, dispositivos de entrada y salida y almacenamiento secundario conectados por el bus del sistema

Figura 1. Arquitectura de von Neumann: las partes de un ordenador conectadas por el bus del sistema.

2.1. La arquitectura de von Neumann

Casi todos los ordenadores actuales (portátiles, móviles, servidores, consolas) siguen el modelo que describió el matemático John von Neumann en 1945. Su gran idea fue que el programa y los datos se guardan juntos en la misma memoria. Así, para cambiar lo que hace el ordenador no hay que recablearlo: basta con cargar otro programa en memoria.

Componente Qué hace Analogía en una cocina
CPU (procesador) Ejecuta las instrucciones, una detrás de otra, a miles de millones por segundo El cocinero
Memoria principal (RAM) Guarda el programa que se está ejecutando y los datos con los que trabaja La encimera: rápida, a mano, pero se limpia al cerrar
Almacenamiento secundario (SSD, disco duro) Guarda ficheros de forma permanente (programas, documentos, fotos) La despensa: cabe mucho, pero hay que ir a buscarlo
Dispositivos de entrada Introducen datos: teclado, ratón, micrófono, cámara, red Los pedidos que llegan
Dispositivos de salida Muestran resultados: pantalla, impresora, altavoces, red Los platos que salen
Bus del sistema Conjunto de “cables” que comunica todas las piezas Los pasillos de la cocina

2.2. La CPU por dentro

El procesador tiene tres partes principales:

  • Unidad de control (UC): dirige todo. Lee la siguiente instrucción de la memoria, averigua qué significa (la decodifica) y da las órdenes necesarias.
  • Unidad aritmético-lógica (ALU): hace las operaciones: sumas, restas, multiplicaciones, comparaciones (¿es a mayor que b?) y operaciones lógicas (Y, O, NO).
  • Registros: unas pocas celdas de memoria dentro de la propia CPU, ultrarrápidas, donde se guardan los datos con los que se opera en cada momento.

La CPU repite sin parar el ciclo de instrucción:

  1. Búsqueda (fetch): la UC trae de la RAM la siguiente instrucción.
  2. Decodificación (decode): averigua qué operación es y qué datos necesita.
  3. Ejecución (execute): la ALU realiza la operación y el resultado se guarda en un registro o en memoria.

📘 Concepto: Un procesador de 3 GHz realiza unos 3 000 millones de ciclos de reloj por segundo. Cada instrucción es extremadamente sencilla (“suma estos dos números”, “copia este dato aquí”, “si el resultado es cero, salta a esa instrucción”), pero a esa velocidad se pueden hacer cosas muy complejas.

2.3. Memoria RAM frente a almacenamiento

Esta distinción es fundamental para entender qué pasa cuando ejecutas un programa:

Característica Memoria RAM Almacenamiento (SSD/disco)
Velocidad Muy rápida (nanosegundos) Más lenta (microsegundos o milisegundos)
Capacidad típica 8-64 GB 256 GB - varios TB
¿Se borra al apagar? Sí (es volátil) No (es permanente)
¿Qué guarda? El programa en ejecución y sus datos (variables) Ficheros: tu código .java, los .class, documentos…

Cuando haces doble clic en un programa, el sistema operativo copia el programa del disco a la RAM y la CPU empieza a ejecutar sus instrucciones desde allí. Cuando en el módulo 03 declares una variable como int edad = 18;, ese 18 vivirá en la RAM mientras el programa se ejecute, y desaparecerá cuando termine.

⚠️ Importante: Si quieres que un dato sobreviva al cierre del programa (por ejemplo, la lista de alumnos de una aplicación), tienes que guardarlo en un fichero o en una base de datos. Lo veremos en el módulo 17.

2.4. Todo son bits

Dentro del ordenador todo (números, letras, imágenes, instrucciones) se representa con bits: ceros y unos, que eléctricamente son “no hay tensión” y “hay tensión”.

Unidad Equivale a Ejemplo
bit 0 o 1 Encendido/apagado
byte 8 bits Un carácter como A (en ASCII es 01000001)
kilobyte (KB) 1 000 bytes Un fichero .java pequeño
megabyte (MB) 1 000 KB Una foto del móvil
gigabyte (GB) 1 000 MB La RAM de un portátil se mide en GB
terabyte (TB) 1 000 GB Un disco externo

💡 Consejo: Técnicamente, 1 KiB (kibibyte) son 1 024 bytes y 1 KB son 1 000 bytes, aunque en el día a día mucha gente usa “KB” para ambos. En el módulo 03 verás que el tamaño en bytes de cada tipo de dato de Java (byte, int, long…) determina qué valores puede guardar.

2.5. El sistema operativo

Entre tu programa y el hardware hay una capa de software muy importante: el sistema operativo (Windows, macOS, Linux, Android…). Se encarga de:

  • Cargar los programas en memoria y repartir la CPU entre todos los que se ejecutan a la vez.
  • Gestionar los ficheros y carpetas del almacenamiento.
  • Controlar los dispositivos de entrada y salida (drivers).
  • Ofrecer a los programas servicios como “abre este fichero” o “escribe esto en pantalla”.

Cada sistema operativo ofrece esos servicios de forma distinta, y cada procesador (Intel/AMD x64, ARM de Apple o de los móviles) entiende instrucciones distintas. Como verás en la sección 7, este es justo el problema que Java resolvió de forma brillante.

3. Programa, algoritmo y lenguaje de programación

3.1. Algoritmo

📘 Concepto: Un algoritmo es una secuencia finita y ordenada de pasos precisos que resuelve un problema. No depende de ningún ordenador ni de ningún lenguaje: una receta de cocina o las instrucciones para montar un mueble son algoritmos.

Ejemplo: algoritmo para calcular la nota media de un examen con dos partes.

1. Pedir la nota de la parte teórica.
2. Pedir la nota de la parte práctica.
3. Sumar las dos notas.
4. Dividir la suma entre 2.
5. Mostrar el resultado.

Un buen algoritmo cumple tres propiedades que estudiaremos a fondo en el módulo 02:

  • Finito: termina después de un número limitado de pasos.
  • Preciso: cada paso indica exactamente qué hacer, sin ambigüedades (“echa un poco de sal” no es preciso).
  • Definido: si lo ejecutas dos veces con los mismos datos, obtienes el mismo resultado.

3.2. Programa

📘 Concepto: Un programa es un algoritmo escrito en un lenguaje de programación, de forma que un ordenador pueda ejecutarlo. El texto que escribe el programador se llama código fuente.

El algoritmo de la nota media, escrito en Java, quedaría así (no te preocupes por entender cada palabra todavía; lo harás en los módulos 01, 03 y 04):

import java.util.Scanner;

public class NotaMedia {
    public static void main(String[] args) {
        Scanner teclado = new Scanner(System.in);
        System.out.print("Nota de teoría: ");
        double teoria = teclado.nextDouble();          // paso 1
        System.out.print("Nota de práctica: ");
        double practica = teclado.nextDouble();        // paso 2
        double media = (teoria + practica) / 2;        // pasos 3 y 4
        System.out.println("Nota media: " + media);    // paso 5
    }
}

Si lo ejecutas e introduces un 6 y un 8, verás:

Nota de teoría: 6
Nota de práctica: 8
Nota media: 7.0

Fíjate en que cada paso del algoritmo se corresponde con una o varias líneas del programa. Primero se piensa el algoritmo y después se traduce al lenguaje. Este orden (pensar antes de teclear) es la clave para programar bien.

3.3. Lenguaje de programación

📘 Concepto: Un lenguaje de programación es un lenguaje artificial, con un vocabulario (palabras reservadas como class, if, while), una sintaxis (reglas de escritura, como terminar las sentencias con ;) y una semántica (qué significa cada construcción), diseñado para expresar algoritmos que un ordenador pueda ejecutar.

A diferencia del español, un lenguaje de programación no admite ambigüedades ni faltas de ortografía. Si en lugar de System.out.println escribes system.out.println (con minúscula), el programa no funcionará. Al principio esto resulta frustrante; enseguida te acostumbrarás a leer los mensajes de error, que en el módulo 01 aprenderás a interpretar.

Término Qué es Ejemplo
Problema Lo que queremos resolver Calcular la nota media
Algoritmo Los pasos para resolverlo, independientes del lenguaje Pedir, sumar, dividir, mostrar
Lenguaje de programación El idioma en el que se escribe el programa Java
Código fuente El texto del programa El fichero NotaMedia.java
Programa ejecutable La forma que el ordenador puede ejecutar NotaMedia.class + la JVM

4. Niveles de los lenguajes de programación

La CPU solo entiende código máquina: secuencias de bits. Escribir programas directamente así sería un infierno, por eso a lo largo de la historia se han creado lenguajes cada vez más cercanos a las personas.

Niveles de lenguaje: alto nivel, ensamblador y código máquina, con la misma operación expresada en cada uno

Figura 2. La misma operación (total = precio * cantidad) en los tres niveles de lenguaje. El código máquina es ilustrativo.

4.1. Código máquina (primera generación)

Instrucciones en binario que la CPU ejecuta directamente. Cada familia de procesadores tiene su propio juego de instrucciones: el código máquina de un procesador Intel no funciona en el ARM de un iPhone.

  • Ventaja: máxima velocidad y control total del hardware.
  • Inconvenientes: ilegible, propenso a errores y nada portable.

4.2. Lenguaje ensamblador (segunda generación)

Sustituye los números por mnemónicos (abreviaturas en inglés): MOV (mover), ADD (sumar), JMP (saltar). Un programa llamado ensamblador traduce cada mnemónico a su instrucción máquina, casi uno a uno.

mov  eax, [precio]      ; copia el valor de precio en el registro EAX
imul eax, [cantidad]    ; multiplica EAX por cantidad
mov  [total], eax       ; guarda el resultado en total

Sigue siendo dependiente del procesador y muy laborioso. Hoy se usa en partes muy concretas: arranque de sistemas operativos, drivers, sistemas embebidos con muy pocos recursos u optimizaciones extremas.

4.3. Lenguajes de alto nivel (tercera generación y siguientes)

Se parecen al lenguaje humano y a la notación matemática, y son independientes del procesador: Fortran (1957), COBOL (1959), C (1972), C++ (1985), Python (1991), Java (1995), JavaScript (1995), PHP (1995), C# (2000), Kotlin (2011), Go (2009), Rust (2015)…

int total = precio * cantidad;

Una sola línea legible sustituye a varias instrucciones de ensamblador. Pero la CPU sigue sin entenderla: hace falta un programa traductor. Cómo se hace esa traducción es lo que distingue a los lenguajes compilados de los interpretados.

💡 Consejo: A veces oirás “lenguaje de bajo nivel” para referirse a C. Es una exageración: C es de alto nivel, pero está cerca del hardware (te deja manejar direcciones de memoria directamente). Java, en cambio, te protege de esos detalles.

5. Compilación, interpretación y JIT

Comparativa entre compilación, interpretación y el modelo híbrido con compilador JIT de Java

Figura 3. Tres formas de ejecutar un programa escrito en un lenguaje de alto nivel.

5.1. Compilación

Un compilador es un programa que traduce todo el código fuente a código máquina antes de ejecutarlo, y genera un fichero ejecutable (en Windows, un .exe).

  • Analogía: traducir un libro entero al español y después leerlo tantas veces como quieras.
  • Ventajas: el ejecutable es muy rápido; el compilador detecta muchos errores antes de ejecutar; no necesitas el código fuente para ejecutar.
  • Inconvenientes: el ejecutable solo funciona en el sistema operativo y procesador para el que se compiló; hay que recompilar para cada plataforma.
  • Ejemplos: C, C++, Go, Rust.

5.2. Interpretación

Un intérprete lee el código fuente y lo traduce y ejecuta instrucción a instrucción, cada vez que se ejecuta el programa.

  • Analogía: un intérprete simultáneo que traduce una conferencia frase a frase mientras se habla.
  • Ventajas: no hay paso previo; el mismo código funciona allí donde haya un intérprete; es cómodo para probar cosas rápidamente.
  • Inconvenientes: más lento (se traduce una y otra vez); muchos errores (por ejemplo, una variable mal escrita) solo aparecen cuando se llega a esa línea.
  • Ejemplos: Python, PHP, Ruby, JavaScript en sus orígenes.

5.3. El modelo de Java: compilación a bytecode + JVM con JIT

Java combina lo mejor de ambos mundos en dos fases:

  1. Compilación a bytecode. El compilador javac traduce tu Hola.java a Hola.class. Ese fichero no contiene código máquina de ningún procesador real, sino bytecode: instrucciones para una máquina imaginaria, la Máquina Virtual de Java (JVM). En esta fase se detectan los errores de sintaxis y de tipos.
  2. Ejecución en la JVM. La JVM carga el .class, lo verifica y empieza a interpretar el bytecode. Mientras tanto, observa qué partes se ejecutan muchas veces (un bucle que se repite un millón de veces, un método muy usado) y las compila a código máquina nativo sobre la marcha. Esto es la compilación JIT (Just-In-Time, “justo a tiempo”).

📘 Concepto: El compilador JIT traduce a código máquina, durante la ejecución, el código “caliente” (el que más se usa) y además lo optimiza con información real de cómo se está comportando el programa. Por eso un programa Java largo va acelerándose después de arrancar, y su rendimiento final se acerca mucho al de un lenguaje compilado.

Modelo Traducción Velocidad Portabilidad Errores detectados antes de ejecutar
Compilado Toda, antes de ejecutar Muy alta Baja (un ejecutable por plataforma) Muchos
Interpretado Instrucción a instrucción, al ejecutar Menor Alta (donde haya intérprete) Pocos
Java (bytecode + JIT) A bytecode antes; a código máquina durante Alta (tras calentar) Muy alta (donde haya JVM) Muchos

💡 Consejo: La frontera hoy es difusa: JavaScript se ejecuta en navegadores con compiladores JIT muy avanzados, Python tiene compiladores a bytecode y existen herramientas como GraalVM Native Image que compilan Java directamente a un ejecutable nativo. Lo importante es entender las ideas.

6. Paradigmas de programación

Un paradigma es un estilo o forma de pensar a la hora de organizar un programa. Un mismo lenguaje puede admitir varios. Java es principalmente orientado a objetos, pero también es imperativo y estructurado y, desde Java 8, permite un estilo funcional.

Paradigma Idea principal Lo verás en
Imperativo El programa es una secuencia de órdenes que van cambiando el estado (las variables) Todo el curso
Estructurado Solo tres estructuras de control: secuencia, selección (if) e iteración (bucles); sin saltos arbitrarios (goto). Se divide en subprogramas Módulos 02-09
Orientado a objetos (POO) El programa se organiza en objetos que combinan datos y comportamiento (un Alumno con su nombre y su método calcularMedia()) Módulos 10-16
Funcional Se describen transformaciones de datos con funciones, sin modificar variables Curso de Java Avanzado
Declarativo / lógico Se describe qué se quiere, no cómo obtenerlo (SQL, Prolog) Curso de Bases de Datos

6.1. El teorema de la programación estructurada

En 1966, Böhm y Jacopini demostraron que cualquier algoritmo puede escribirse usando solo tres estructuras: secuencia, selección e iteración. En los años 70, Edsger Dijkstra popularizó la idea de abandonar las instrucciones goto (saltar a cualquier línea), que generaban programas imposibles de seguir (el famoso “código espagueti”). Toda la primera parte de este curso sigue esta forma de programar.

6.2. Imperativo frente a funcional en Java

💻 Ejemplo: El mismo cálculo (sumar los números del 1 al 10) en dos estilos. No hace falta que entiendas todavía la sintaxis; fíjate en la diferencia de enfoque.

import java.util.stream.IntStream;

public class Paradigmas {
    public static void main(String[] args) {
        // Estilo imperativo/estructurado: decimos CÓMO hacerlo, paso a paso
        int suma = 0;
        for (int i = 1; i <= 10; i++) {
            suma = suma + i;
        }
        System.out.println("Imperativo: " + suma);

        // Estilo funcional: decimos QUÉ queremos (la suma del rango 1..10)
        int sumaFuncional = IntStream.rangeClosed(1, 10).sum();
        System.out.println("Funcional:  " + sumaFuncional);
    }
}

Salida:

Imperativo: 55
Funcional:  55

En este curso empezarás por el estilo imperativo y estructurado, porque es el que te enseña a pensar los algoritmos paso a paso. Después pasarás a la orientación a objetos, que es la forma de organizar programas grandes.

7. Historia de Java

7.1. Del Green Project a Java

  • 1991. En Sun Microsystems, un pequeño equipo dirigido por James Gosling (junto a Mike Sheridan y Patrick Naughton) inicia el Green Project. El objetivo: crear software para electrodomésticos y dispositivos de consumo (descodificadores de televisión, mandos…). Necesitaban un lenguaje que funcionara en chips muy distintos sin reescribir el código.
  • Gosling crea un lenguaje inspirado en C y C++, pero más sencillo y seguro, al que llama Oak (roble), por el árbol que veía desde la ventana de su oficina.
  • 1992. El equipo presenta el *7 (Star Seven), un mando a distancia con pantalla táctil programado en Oak. Técnicamente era impresionante, pero el mercado de la televisión interactiva no estaba preparado.
  • 1994-1995. Llega la explosión de la World Wide Web. El equipo se da cuenta de que su lenguaje, pensado para funcionar en cualquier dispositivo, es perfecto para una red donde se conectan ordenadores de todo tipo. Como “Oak” era ya una marca registrada, se renombra como Java (en honor al café de la isla de Java, de ahí el logotipo de la taza humeante).
  • 23 de mayo de 1995. Sun presenta oficialmente Java en la conferencia SunWorld, junto con el navegador HotJava, capaz de ejecutar pequeños programas Java dentro de las páginas web (los applets). Poco después, Netscape anuncia que su navegador también los soportará.
  • Enero de 1996. Se publica JDK 1.0.

7.2. Evolución: de Sun a Oracle

  • 2006-2007. Sun publica el código de Java como software libre (licencia GPL) en el proyecto OpenJDK, que hoy es la base de todas las distribuciones de Java.
  • 2010. Oracle completa la compra de Sun Microsystems y pasa a dirigir la evolución de Java, junto con la comunidad de OpenJDK y el JCP (Java Community Process), el organismo donde empresas y particulares acuerdan las especificaciones.
  • 2017-2018. Con Java 9 y 10 cambia el modelo de publicación: una versión nueva cada seis meses.

💡 Consejo: Java y JavaScript no tienen nada que ver, salvo el nombre y algo de sintaxis heredada de C. El nombre “JavaScript” fue una decisión de marketing de Netscape en 1995 para aprovechar la popularidad de Java.

7.3. Tabla de versiones

Versión Fecha Novedades destacadas
JDK 1.0 enero 1996 Primera versión: lenguaje, applets, AWT
JDK 1.1 febrero 1997 Clases internas, JDBC (bases de datos), reflexión
J2SE 1.2 diciembre 1998 Colecciones, Swing (interfaces gráficas), compilador JIT incluido
J2SE 1.3 mayo 2000 Máquina virtual HotSpot por defecto
J2SE 1.4 febrero 2002 assert, expresiones regulares, NIO
J2SE 5.0 septiembre 2004 Genéricos, enum, autoboxing, bucle for-each, anotaciones
Java SE 6 diciembre 2006 Mejoras de rendimiento y de la API
Java SE 7 julio 2011 try-with-resources, operador diamante <>, switch con String
Java SE 8 (LTS) marzo 2014 Expresiones lambda, streams, API de fechas java.time
Java SE 9 septiembre 2017 Sistema de módulos, JShell
Java SE 10 marzo 2018 var (inferencia de tipos). Empieza la cadencia semestral
Java SE 11 (LTS) septiembre 2018 Cliente HTTP, ejecutar java Programa.java sin compilar antes
Java SE 14 marzo 2020 Expresiones switch
Java SE 15 septiembre 2020 Text blocks (cadenas multilínea)
Java SE 16 marzo 2021 Records
Java SE 17 (LTS) septiembre 2021 Clases selladas (sealed)
Java SE 21 (LTS) septiembre 2023 Hilos virtuales, pattern matching en switch, record patterns, colecciones secuenciadas
Java SE 22 marzo 2024 Variables sin nombre _, programas de varios ficheros sin compilar
Java SE 23 septiembre 2024 Comentarios de documentación en Markdown
Java SE 24 marzo 2025 Stream gatherers
Java SE 25 (LTS) septiembre 2025 Ficheros fuente compactos con void main(), clase IO, import module, cuerpos de constructor flexibles, scoped values
Java SE 26 marzo 2026 Cliente HTTP/3, eliminación definitiva de la API de applets
Java SE 27 septiembre 2026 G1 como recolector por defecto en todos los entornos, cabeceras de objeto compactas por defecto

📘 Concepto: Hasta la versión 1.4 se usaba la numeración “1.x”. A partir de la 5.0 se abandonó el “1.” en el nombre comercial (aunque internamente Java 8 seguía siendo “1.8”). Desde Java 9, la versión es simplemente un número: 9, 10, 11… 25.

7.4. Cadencia semestral y versiones LTS

Desde 2018 se publica una versión de Java cada seis meses, en marzo y septiembre. Cada versión trae pocas novedades, pero llegan antes y de forma predecible.

No todas las versiones son iguales:

  • Versiones LTS (Long-Term Support, soporte a largo plazo): reciben actualizaciones de seguridad y correcciones durante muchos años (Oracle y otros proveedores las mantienen al menos 8 años). Son las que usan las empresas en producción. Desde Java 17 hay una LTS cada dos años: 17 (2021), 21 (2023), 25 (2025), y la siguiente prevista es la 29 (2027).
  • Versiones no LTS (22, 23, 24, 26, 27…): solo reciben actualizaciones durante seis meses, hasta que sale la siguiente. Sirven para probar novedades.

⚠️ Importante: Este curso usa Java 25, la LTS actual. En septiembre de 2026 salió Java 27, que es más reciente pero no es LTS. Todo lo que aprendas con Java 25 funciona igual en Java 27. Si en una empresa te encuentras con Java 17 o 21, también podrás trabajar sin problema: los fundamentos no cambian.

7.5. Características preview e incubadoras

Algunas novedades aparecen primero como preview (vista previa): están completas pero pueden cambiar, y para usarlas hay que activar la opción --enable-preview. Así la comunidad las prueba antes de que sean definitivas. Por ejemplo, los ficheros fuente compactos con void main() estuvieron en preview desde Java 21 hasta que fueron definitivos en Java 25. Otras, como la concurrencia estructurada, siguen en preview en Java 25, 26 y 27. En este curso solo usaremos características definitivas.

8. Características de Java

Cuando Sun presentó Java, lo describió con una lista de cualidades que siguen siendo válidas:

Característica Qué significa
Sencillo Sintaxis parecida a C/C++ pero sin sus partes más peligrosas (punteros, gestión manual de memoria, herencia múltiple de clases)
Orientado a objetos Todo el código se organiza en clases y objetos
Portable / independiente de la plataforma El mismo .class funciona en cualquier sistema con una JVM: “Write once, run anywhere”
Robusto Tipado estricto, comprobaciones del compilador, excepciones para gestionar errores, sin acceso directo a la memoria
Seguro La JVM verifica el bytecode antes de ejecutarlo y controla lo que puede hacer el programa
Gestión automática de memoria El recolector de basura (garbage collector) libera la memoria de los objetos que ya no se usan
Multihilo Permite ejecutar varias tareas a la vez (hilos), integrado en el lenguaje desde el principio
Alto rendimiento Gracias al compilador JIT
Gran biblioteca estándar Miles de clases listas para usar: textos, fechas, colecciones, ficheros, red, bases de datos…
Compatibilidad hacia atrás Un programa escrito para Java 8 suele funcionar sin cambios en Java 25

8.1. “Write once, run anywhere”

Este es el lema más famoso de Java: escribe una vez, ejecuta en cualquier parte. Tú compilas tu programa una sola vez y el .class resultante funciona en Windows, macOS, Linux o en un servidor, siempre que haya una JVM instalada. Es la JVM de cada sistema la que se encarga de traducir el bytecode al código máquina de ese procesador.

Proceso de Java: Hola.java se compila con javac a Hola.class, que se ejecuta en las JVM de Windows, macOS y Linux

Figura 4. El fichero Hola.class es el mismo para todos los sistemas; lo que cambia es la JVM.

💻 Ejemplo: Este programa muestra información del sistema en el que se está ejecutando:

public class DondeEstoy {
    public static void main(String[] args) {
        // System.getProperty consulta datos del entorno en el que se ejecuta la JVM
        System.out.println("Versión de Java: " + System.getProperty("java.version"));
        System.out.println("Fabricante:      " + System.getProperty("java.vendor"));
        System.out.println("Sistema:         " + System.getProperty("os.name"));
        System.out.println("Arquitectura:    " + System.getProperty("os.arch"));
        System.out.println("Procesadores:    " + Runtime.getRuntime().availableProcessors());
    }
}

Ejecutado en un contenedor Linux con el JDK 25 de Eclipse Temurin:

Versión de Java: 25.0.4.1
Fabricante:      Eclipse Adoptium
Sistema:         Linux
Arquitectura:    amd64
Procesadores:    8

Y el mismo fichero, sin cambiar ni una letra, en un portátil con Windows 11 y otro JDK:

Versión de Java: 21.0.4
Fabricante:      Oracle Corporation
Sistema:         Windows 11
Arquitectura:    amd64
Procesadores:    12

9. La plataforma Java: JVM, bytecode, JRE y JDK

Estos cuatro términos aparecen constantemente y es normal confundirlos al principio. Vamos uno por uno.

JDK, JRE y JVM como cajas anidadas: el JDK contiene herramientas y el JRE; el JRE contiene la biblioteca estándar y la JVM

Figura 5. Relación entre JDK, JRE y JVM.

9.1. Bytecode

📘 Concepto: El bytecode es el código intermedio que genera javac. Son instrucciones sencillas para la JVM, guardadas en ficheros .class. Se llama así porque cada código de operación ocupa un byte.

Puedes ver el bytecode de cualquier clase con la herramienta javap -c, incluida en el JDK. Para este programa:

public class Suma {
    public static void main(String[] args) {
        int precio = 12;
        int cantidad = 3;
        int total = precio * cantidad;
        System.out.println(total);
    }
}

Al compilarlo con javac Suma.java y ejecutar javap -c Suma, el JDK 25 muestra (fragmento del método main):

  public static void main(java.lang.String[]);
    Code:
         0: bipush        12
         2: istore_1
         3: iconst_3
         4: istore_2
         5: iload_1
         6: iload_2
         7: imul
         8: istore_3
         9: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
        12: iload_3
        13: invokevirtual #13                 // Method java/io/PrintStream.println:(I)V
        16: return

Aunque parezca críptico, se puede leer: bipush 12 mete el número 12 en la pila de operandos; istore_1 lo guarda en la variable 1 (precio); iconst_3 e istore_2 hacen lo mismo con el 3 (cantidad); iload_1 e iload_2 cargan ambos valores, imul los multiplica (integer multiply), istore_3 guarda el resultado en total, y las últimas instrucciones llaman a println.

💡 Consejo: Nunca tendrás que escribir bytecode a mano. Pero saber que existe te ayuda a entender por qué Java es portable y por qué a veces verás errores como UnsupportedClassVersionError (lo vemos en la sección 9.6).

Todo fichero .class empieza con los mismos cuatro bytes, el “número mágico” CA FE BA BE (en hexadecimal; “cafe babe”), un guiño de sus creadores al café. Los siguientes bytes indican la versión del formato: en Java 25 es la 69 (00 45 en hexadecimal).

9.2. JVM (Java Virtual Machine)

📘 Concepto: La JVM es un programa que simula un ordenador capaz de ejecutar bytecode. Hay una JVM distinta para cada sistema operativo y procesador, pero todas ejecutan el mismo bytecode de la misma forma.

Sus partes principales:

  • Cargador de clases (class loader): busca y carga en memoria los .class que necesita el programa, cuando los necesita.
  • Verificador de bytecode: comprueba que el código es válido y seguro (que no accede a memoria que no le corresponde, por ejemplo).
  • Motor de ejecución: el intérprete y el compilador JIT. La JVM más usada, HotSpot, se llama así precisamente porque detecta los “puntos calientes” del código para compilarlos.
  • Recolector de basura (garbage collector, GC): libera automáticamente la memoria de los objetos que ya no se usan. En C tendrías que hacerlo tú a mano, y olvidarlo es una fuente de errores graves.

La especificación de la JVM es pública, y por eso existen otros lenguajes que se compilan a bytecode y se ejecutan en ella: Kotlin (el lenguaje recomendado para Android), Scala, Groovy o Clojure.

9.3. JRE (Java Runtime Environment)

El JRE es el entorno de ejecución: la JVM más la biblioteca estándar de Java (las miles de clases ya hechas como String, Scanner, ArrayList, Math…). Es lo mínimo que necesita un ordenador para ejecutar programas Java, pero no para crearlos.

⚠️ Importante: Desde Java 11, Oracle ya no distribuye un JRE por separado: se instala el JDK completo o se genera un entorno de ejecución a medida con la herramienta jlink. Algunas distribuciones (como Eclipse Temurin) siguen ofreciendo paquetes JRE, pero tú, como programador, siempre instalarás el JDK.

9.4. JDK (Java Development Kit)

El JDK es el kit de desarrollo: el JRE más las herramientas para programar. Las que usarás en el curso:

Herramienta Para qué sirve Módulo
javac Compilar: .java → .class 01
java Lanzar la JVM y ejecutar un programa (o un .java directamente) 01
jshell Consola interactiva para probar código línea a línea 01
javadoc Generar documentación HTML a partir de los comentarios 20
jar Empaquetar muchas clases en un único fichero .jar 20
javap Ver el contenido de un .class (como el bytecode de antes) 00
jdb Depurador en modo texto (en la práctica usarás el del IDE) 19

9.5. Resumen: ¿qué necesito?

Si quieres… Necesitas Ejemplo
Ejecutar una aplicación Java ya hecha Un entorno de ejecución (JRE o un runtime de jlink) Un usuario que juega a Minecraft Java Edition
Escribir, compilar y ejecutar programas Java El JDK Tú en este curso
Entender cómo se ejecuta el bytecode Conocer la JVM Para depurar problemas de rendimiento o de memoria

9.6. Versiones de bytecode e incompatibilidades

Cada versión de Java genera bytecode con un número de versión (Java 21 → 65, Java 25 → 69, Java 27 → 71). Una JVM puede ejecutar bytecode de su versión o anteriores, pero no de versiones posteriores. Si compilas con el JDK 25 y ejecutas en una JVM 21, obtendrás este error real:

Error: LinkageError occurred while loading main class Hola
	java.lang.UnsupportedClassVersionError: Hola has been compiled by a more recent version of the Java Runtime (class file version 69.0), this version of the Java Runtime only recognizes class file versions up to 65.0

El mensaje lo dice todo: la clase se compiló con la versión 69.0 (Java 25) y esa JVM solo reconoce hasta la 65.0 (Java 21). La solución es ejecutar con una JVM igual o más moderna que el compilador.

💡 Consejo: Si te pasa en clase, casi siempre es porque tienes dos JDK instalados y javac y java apuntan a versiones distintas. En el módulo 01 verás cómo comprobarlo con java -version y javac -version y cómo configurar JAVA_HOME y PATH.

10. Distribuciones del JDK

Como Java es software libre (OpenJDK), varias empresas y fundaciones compilan y publican su propia distribución del JDK. Todas se construyen a partir del mismo código de OpenJDK y pasan las mismas pruebas de compatibilidad, así que un programa funciona igual con cualquiera de ellas. Lo que cambia es quién las mantiene, la licencia y durante cuánto tiempo publican actualizaciones.

Distribución Mantenida por Comentario
Eclipse Temurin Fundación Eclipse (proyecto Adoptium) Gratuita y de código abierto, con soporte LTS. La recomendada en este curso
Oracle JDK Oracle La “oficial” de Oracle. Gratuita según sus términos de licencia (NFTC); consulta las condiciones si la vas a usar en una empresa
Oracle OpenJDK builds Oracle (jdk.java.net) Gratuitas (GPL), pero solo se actualizan durante 6 meses por versión
Amazon Corretto Amazon Gratuita, muy usada en AWS
Microsoft Build of OpenJDK Microsoft Gratuita, usada en Azure
Azul Zulu Azul Systems Gratuita, con soporte comercial opcional
BellSoft Liberica BellSoft Gratuita; incluye variantes con JavaFX
Red Hat build of OpenJDK Red Hat Integrada en Red Hat Enterprise Linux
GraalVM Oracle JDK con compilador avanzado y generación de ejecutables nativos

💡 Consejo: Para aprender, cualquiera vale. Elige una distribución LTS (versión 25) de Temurin o de Oracle y no te preocupes más. IntelliJ IDEA, además, puede descargar cualquiera de ellas por ti con un par de clics (lo verás en el módulo 01).

11. ¿Dónde se usa Java hoy?

Java lleva tres décadas entre los lenguajes más usados del mundo. Algunos ejemplos de dónde lo encontrarás:

Ámbito Ejemplos
Aplicaciones empresariales (backend) Bancos, aseguradoras, administraciones públicas, comercio electrónico. Frameworks como Spring Boot (lo verás en el Curso de Java Avanzado)
Android El sistema y muchas aplicaciones se programan en Java y Kotlin, ambos sobre la plataforma Java
Big data y sistemas distribuidos Apache Hadoop, Apache Kafka, Elasticsearch, Apache Cassandra, Apache Spark (en Scala, sobre la JVM)
Herramientas de desarrollo IntelliJ IDEA, Eclipse, NetBeans, Maven, Gradle o Jenkins están escritos en Java
Videojuegos Minecraft: Java Edition
Servicios en la nube Microservicios en AWS, Azure o Google Cloud
Sistemas embebidos y tarjetas Java Card en tarjetas SIM y bancarias, dispositivos industriales
Ciencia y educación Simulaciones, procesamiento de datos y, por supuesto, la enseñanza de la programación

📘 Concepto: Aprender Java no solo te sirve para Java. Los conceptos (variables, condicionales, bucles, métodos, clases, objetos, excepciones, colecciones) son los mismos en C#, Kotlin, TypeScript, Python o C++. Cambia la sintaxis, pero la forma de pensar es la misma.

12. Ciclo de vida del desarrollo de un programa

Un programa profesional no se escribe “de golpe”. Pasa por varias fases, que forman el ciclo de vida del desarrollo del software.

Ciclo de vida del desarrollo: análisis, diseño, codificación, pruebas, despliegue y mantenimiento

Figura 6. Fases del ciclo de vida del desarrollo de un programa.

Fase Pregunta que responde Resultado En este curso
1. Análisis ¿Qué tiene que hacer el programa? Lista de requisitos: entradas, salidas, reglas Leer bien el enunciado de cada ejercicio
2. Diseño ¿Cómo lo va a hacer? Algoritmos (pseudocódigo, diagramas de flujo), diagramas UML Módulos 02 y 18
3. Codificación Escribir el programa Código fuente en Java Todo el curso
4. Pruebas ¿Funciona en todos los casos? Errores encontrados y corregidos Trazas (módulo 02), JUnit y depuración (módulo 19)
5. Despliegue / explotación Ponerlo en manos de los usuarios Programa instalado y en uso Proyecto final (módulo 21)
6. Mantenimiento Corregir, adaptar y mejorar Nuevas versiones Refactorización (módulo 20)

12.1. Un ejemplo completo

Enunciado: “Necesitamos un programa que calcule el precio final de un producto aplicando el IVA del 21 %”.

  1. Análisis. Entrada: el precio sin IVA (un número con decimales). Salida: el precio con IVA. Regla: precio final = precio × 1,21. Casos especiales: ¿y si el precio es negativo? Hay que preguntarlo al cliente: decidimos que se mostrará un aviso.
  2. Diseño. Algoritmo: leer precio; si es negativo, mostrar aviso; si no, calcular precio * 1.21 y mostrarlo.
  3. Codificación. Escribir el programa en Java (sabrás hacerlo al terminar el módulo 05).
  4. Pruebas. Probar con 100 (debe dar 121), con 0 (debe dar 0), con 19,99 (debe dar 24,19 redondeado) y con −5 (debe mostrar el aviso).
  5. Despliegue. Entregar el programa al cliente.
  6. Mantenimiento. Meses después, el cliente pide que también calcule el IVA reducido del 10 %: se vuelve a la fase de análisis.

⚠️ Importante: El error más común de quien empieza es saltar directamente a la codificación. Si no has entendido bien el problema (análisis) ni sabes cómo resolverlo (diseño), teclear no te va a ayudar. Dedica tiempo a pensar con papel y lápiz.

12.2. Modelos de ciclo de vida

Las fases se pueden organizar de distintas formas:

  • En cascada: cada fase empieza cuando termina la anterior. Sencillo, pero poco flexible ante cambios.
  • Iterativo e incremental: se repite el ciclo completo muchas veces, cada vez añadiendo funcionalidad.
  • Metodologías ágiles (Scrum, Kanban): ciclos cortos de una a cuatro semanas con entregas frecuentes y contacto continuo con el cliente. Son las más usadas hoy en las empresas.

12.3. Tipos de errores

Durante el desarrollo te encontrarás con tres tipos de errores:

Tipo Cuándo aparece Ejemplo Quién lo detecta
De compilación (sintácticos) Al compilar con javac Olvidar un ; o escribir Sytem en vez de System El compilador, que te dice la línea
De ejecución Mientras se ejecuta Dividir un entero entre cero, leer una letra donde se esperaba un número La JVM, que lanza una excepción
Lógicos El programa funciona pero da un resultado incorrecto Calcular la media como a + b / 2 en lugar de (a + b) / 2 Tú, con pruebas

Los errores lógicos son los más peligrosos, porque nadie te avisa. Por eso las pruebas son una fase tan importante.

13. Ejercicios

Estos ejercicios son principalmente conceptuales: el objetivo es que fijes las ideas de este módulo. En el módulo 01 empezarás a programar.

Ejercicio 1: Clasifica los componentes

Indica si cada elemento es un dispositivo de entrada (E), de salida (S), de entrada/salida (E/S), almacenamiento (A) o parte de la CPU/memoria (C): teclado, monitor, pantalla táctil, memoria RAM, SSD, ALU, impresora, micrófono, tarjeta de red, pendrive USB, registros, altavoces.

Ver solución
Elemento Tipo Explicación
Teclado E Introduce datos
Monitor S Muestra resultados
Pantalla táctil E/S Muestra imágenes y recoge pulsaciones
Memoria RAM C Memoria principal: programa y datos en ejecución
SSD A Almacenamiento permanente
ALU C Parte de la CPU que hace los cálculos
Impresora S Saca resultados en papel (las multifunción con escáner serían E/S)
Micrófono E Introduce sonido
Tarjeta de red E/S Envía y recibe datos
Pendrive USB A Almacenamiento permanente extraíble
Registros C Memoria ultrarrápida dentro de la CPU
Altavoces S Emiten sonido

La clave para distinguir RAM de almacenamiento: la RAM es volátil y la usa la CPU directamente; el almacenamiento es permanente y guarda ficheros.

Ejercicio 2: Un algoritmo cotidiano

Escribe un algoritmo, en pasos numerados, para sacar dinero de un cajero automático. Después revísalo: ¿qué pasa si el PIN es incorrecto? ¿Y si no hay saldo suficiente? Reescríbelo para que tenga en cuenta esos casos.

Ver solución

Primera versión (la que escribe casi todo el mundo):

1. Introducir la tarjeta.
2. Teclear el PIN.
3. Elegir "Retirar efectivo".
4. Teclear la cantidad.
5. Recoger el dinero.
6. Recoger la tarjeta.

Versión mejorada, teniendo en cuenta los casos especiales:

1. Introducir la tarjeta.
2. Teclear el PIN.
3. Si el PIN es incorrecto:
     3.1. Si es el tercer intento fallido, el cajero retiene la tarjeta y termina.
     3.2. Si no, volver al paso 2.
4. Elegir "Retirar efectivo".
5. Teclear la cantidad.
6. Si la cantidad es mayor que el saldo disponible:
     6.1. Mostrar "Saldo insuficiente" y volver al paso 5.
7. Recoger la tarjeta.
8. Recoger el dinero.
9. Fin.

Observa tres ideas que desarrollaremos en el módulo 02: aparecen decisiones (“si…”), repeticiones (“volver al paso 2”) y el algoritmo debe ser finito (por eso se limita el número de intentos del PIN). Fíjate también en que los cajeros reales devuelven la tarjeta antes que el dinero, para que nadie se la olvide: ¡el orden de los pasos importa!

Ejercicio 3: ¿Compilado, interpretado o híbrido?

Para cada situación, indica si describe un lenguaje compilado, interpretado o el modelo híbrido de Java:

  1. El programa se distribuye como un .exe que solo funciona en Windows.
  2. Para ejecutar el programa hace falta tener instalado el código fuente y un programa que lo lea línea a línea.
  3. El código se traduce a un formato intermedio que se puede ejecutar en cualquier sistema con la máquina virtual adecuada.
  4. Un error de escritura en una línea que solo se ejecuta los domingos no se descubre hasta un domingo.
  5. Mientras el programa se ejecuta, las partes más usadas se traducen a código máquina para ir más rápido.
Ver solución
  1. Compilado. El compilador genera código máquina para un sistema y procesador concretos.
  2. Interpretado. El intérprete necesita el código fuente en cada ejecución.
  3. Híbrido (Java). El formato intermedio es el bytecode y la máquina virtual es la JVM.
  4. Interpretado. En un lenguaje compilado (o en Java), el compilador detectaría el error de sintaxis antes de ejecutar nada, sin importar el día.
  5. Híbrido con JIT. Es lo que hace la JVM HotSpot con el código “caliente”.

Ejercicio 4: JDK, JRE o JVM

Responde a cada pregunta con JDK, JRE o JVM:

  1. ¿Qué contiene el compilador javac?
  2. ¿Qué pieza traduce el bytecode al código máquina del procesador?
  3. ¿Qué necesita como mínimo un usuario que solo quiere ejecutar una aplicación Java ya hecha?
  4. ¿Qué debes instalar para seguir este curso?
  5. ¿Dónde está el recolector de basura?
  6. ¿Dónde está la clase String de la biblioteca estándar?
Ver solución
  1. JDK. Las herramientas de desarrollo (javac, jshell, javadoc…) solo están en el JDK.
  2. JVM, mediante su intérprete y su compilador JIT.
  3. Un JRE (o un entorno de ejecución generado con jlink). Hoy muchas aplicaciones incluyen su propio entorno de ejecución dentro del instalador.
  4. El JDK (versión 25).
  5. En la JVM.
  6. En la biblioteca estándar, que forma parte del JRE (y, por tanto, también del JDK, que lo contiene).

Ejercicio 5: Calendario de versiones

Sabiendo que Java publica una versión cada seis meses (marzo y septiembre) y una LTS cada dos años desde Java 17 (septiembre de 2021):

  1. ¿En qué mes y año se espera Java 28?
  2. ¿Cuál será la próxima LTS después de Java 25 y cuándo se espera?
  3. Una empresa usa Java 21 en producción. ¿Por qué no ha actualizado a Java 22, 23 o 24?
Ver solución
  1. Java 27 salió en septiembre de 2026, así que Java 28 se espera en marzo de 2027.
  2. Las LTS van de cuatro en cuatro versiones (17, 21, 25…), así que la siguiente será Java 29, prevista para septiembre de 2027.
  3. Porque 22, 23 y 24 no son LTS: solo recibieron actualizaciones de seguridad durante seis meses. Una empresa prefiere saltar de LTS en LTS (de 21 a 25), porque así tiene años de actualizaciones garantizadas y no necesita migrar cada seis meses.

Ejercicio 6: Leer bytecode

Este programa calcula el área de un triángulo:

public class Triangulo {
    public static void main(String[] args) {
        int base = 10;
        int altura = 4;
        int area = base * altura / 2;
        System.out.println(area);
    }
}

Este es el bytecode real de su método main (obtenido con javap -c Triangulo):

         0: bipush        10
         2: istore_1
         3: iconst_4
         4: istore_2
         5: iload_1
         6: iload_2
         7: imul
         8: iconst_2
         9: idiv
        10: istore_3
        11: getstatic     #7                  // Field java/lang/System.out:Ljava/io/PrintStream;
        14: iload_3
        15: invokevirtual #13                 // Method java/io/PrintStream.println:(I)V
        18: return
  1. ¿Qué instrucciones corresponden a la línea int area = base * altura / 2;?
  2. ¿Qué crees que significa idiv?
  3. ¿Qué mostrará el programa?
Ver solución
  1. Las instrucciones de la 5 a la 10: iload_1 (carga base), iload_2 (carga altura), imul (multiplica: 40), iconst_2 (carga la constante 2), idiv (divide: 20) e istore_3 (guarda el resultado en la variable 3, que es area).
  2. Integer divide: división entera. La i inicial de muchas instrucciones significa que trabajan con enteros (int).
  3. Muestra 20. Compilado y ejecutado con el JDK 25:
20

Fíjate en que las operaciones se hacen en el mismo orden en que las lees en Java (primero la multiplicación y luego la división, de izquierda a derecha). En el módulo 03 estudiarás la precedencia de operadores, que decide ese orden.

Ejercicio 7: Clasifica los errores

Indica si cada uno es un error de compilación, de ejecución o lógico:

  1. Escribir int edad = 18 sin el punto y coma final.
  2. Un programa que calcula el precio con IVA multiplica por 0.21 en lugar de por 1.21.
  3. El programa pide un número y el usuario escribe “hola”.
  4. Escribir Sytem.out.println("Hola");.
  5. Un programa que debía mostrar los números del 1 al 10 muestra del 1 al 9.
Ver solución
  1. De compilación. javac responde con error: ';' expected indicando la línea.
  2. Lógico. El programa funciona, pero muestra solo el importe del IVA en lugar del precio final.
  3. De ejecución. El programa compila, pero al intentar convertir “hola” en número la JVM lanza una excepción (InputMismatchException, la verás en el módulo 04).
  4. De compilación. El compilador no conoce nada llamado Sytem; como va seguido de un punto, supone que es un paquete y responde package Sytem does not exist (lo verás en el módulo 01).
  5. Lógico. Típico error “por uno” (off-by-one), probablemente por usar < en lugar de <= en un bucle (módulo 06).

Ejercicio 8 (propuesto): Tu ordenador

Averigua las características de tu ordenador (en Windows: Configuración → Sistema → Información; en macOS: menú Apple → Acerca de este Mac; en Linux: lscpu y free -h): modelo de procesador, número de núcleos, cantidad de RAM y capacidad del almacenamiento. Relaciona cada dato con una caja de la figura 1.

Ejercicio 9 (propuesto): Receta precisa

Escribe el algoritmo para preparar un vaso de cacao con leche con el nivel de precisión que necesitaría un robot que no sabe nada de cocina. Después, pide a otra persona que lo siga literalmente y apunta los pasos que resultaron ambiguos.

Ejercicio 10 (propuesto): Línea del tiempo

Dibuja una línea del tiempo desde 1991 hasta hoy con los hitos de Java: Green Project, Oak, presentación de Java, JDK 1.0, OpenJDK, compra por Oracle, inicio de la cadencia semestral y todas las versiones LTS. Marca la versión que usa el curso.

Ejercicio 11 (propuesto): Busca Java a tu alrededor

Busca tres aplicaciones o servicios que uses habitualmente y averigua (en su web, en ofertas de empleo de la empresa o en artículos técnicos) si utilizan Java o algún lenguaje de la JVM (Kotlin, Scala). Indica la fuente donde lo has encontrado.

Ejercicio 12 (propuesto): Ciclo de vida de una aplicación

Para el enunciado “Aplicación que gestiona el préstamo de libros de la biblioteca del instituto”, escribe qué se haría en cada una de las seis fases del ciclo de vida. En la fase de análisis, enumera al menos cinco requisitos y dos casos especiales (por ejemplo, ¿qué pasa si alguien intenta llevarse un libro que ya está prestado?).

Ejercicio 13 (propuesto): Paradigmas

Explica con tus palabras la diferencia entre el paradigma imperativo y el declarativo usando un ejemplo de la vida real (por ejemplo, pedir un taxi indicando cada giro frente a decir solo la dirección de destino). ¿A qué paradigma pertenece SQL? ¿Y Java?

Resumen

Concepto Idea clave
Arquitectura de von Neumann CPU + memoria (programa y datos juntos) + E/S + almacenamiento, unidos por el bus
CPU Unidad de control + ALU + registros; ciclo búsqueda-decodificación-ejecución
RAM frente a almacenamiento RAM: rápida y volátil (programa en ejecución). Almacenamiento: permanente (ficheros)
Algoritmo Secuencia finita, precisa y definida de pasos que resuelve un problema
Programa Algoritmo escrito en un lenguaje de programación (código fuente)
Niveles de lenguaje Código máquina → ensamblador → alto nivel (Java)
Compilador Traduce todo el programa a código máquina antes de ejecutar
Intérprete Traduce y ejecuta instrucción a instrucción
Bytecode Código intermedio de Java (.class), igual para todos los sistemas
JIT La JVM compila a código máquina, durante la ejecución, el código más usado
JVM Máquina virtual que ejecuta bytecode; una por cada sistema
JRE JVM + biblioteca estándar: lo necesario para ejecutar
JDK JRE + herramientas (javac, java, jshell, javadoc…): lo necesario para programar
Write once, run anywhere Se compila una vez; el .class funciona en cualquier JVM
Versiones Una cada seis meses; LTS cada dos años: 17, 21, 25 (la del curso), 29…
Distribuciones Temurin, Oracle JDK, Corretto, Microsoft, Zulu, Liberica…: todas basadas en OpenJDK
Paradigmas Imperativo, estructurado, orientado a objetos, funcional, declarativo
Ciclo de vida Análisis → diseño → codificación → pruebas → despliegue → mantenimiento
Tipos de errores De compilación, de ejecución y lógicos
Navegación  
← Inicio del curso Siguiente módulo: Entorno de desarrollo →