Audio del tema Presentación del curso en audio (IA)
1. Presentación del curso de programación con Java
Bienvenido al curso de programación con Java. Este curso está pensado para aprender a programar desde la base, empezando por los conceptos más sencillos y avanzando poco a poco hasta llegar a la programación orientada a objetos, uno de los pilares fundamentales de Java y de muchos lenguajes modernos.
A lo largo del curso no vamos a limitarnos a memorizar instrucciones ni a copiar código sin entenderlo. El objetivo principal es aprender a pensar como programadores. Esto significa aprender a analizar problemas, dividirlos en partes más pequeñas, plantear soluciones ordenadas y convertir esas soluciones en programas que pueda ejecutar un ordenador.
Java será el lenguaje que utilizaremos para aprender estos conceptos. Es un lenguaje muy utilizado en el mundo profesional, especialmente en aplicaciones de empresa, aplicaciones web, aplicaciones móviles, sistemas de gestión, herramientas internas y muchos otros tipos de software. Además, Java es un lenguaje muy adecuado para aprender programación porque obliga a trabajar de forma ordenada y ayuda a comprender muy bien conceptos importantes como variables, condiciones, bucles, funciones, clases, objetos, herencia y estructuras de datos.
Durante el curso utilizaremos Eclipse como entorno de desarrollo. Eclipse es un IDE, es decir, un programa que nos ayuda a escribir, organizar, ejecutar y depurar nuestro código. Aunque al principio puede parecer una herramienta con muchas opciones, poco a poco iremos usando solamente las partes necesarias. La idea no es aprender Eclipse por aprender Eclipse, sino usarlo como herramienta para programar mejor.
Este primer curso será la base de una formación más amplia. Después de aprender los fundamentos de Java, se podrá continuar con tecnologías más avanzadas como Java EE y posteriormente Spring, que son herramientas muy utilizadas para crear aplicaciones web y sistemas empresariales. Por eso es importante construir ahora una base sólida. Si entendemos bien los fundamentos, todo lo que venga después será mucho más fácil de asimilar.
Programar no consiste en saber todas las instrucciones de memoria. De hecho, incluso los programadores profesionales consultan documentación, buscan ejemplos y revisan código continuamente. Lo importante es comprender cómo se resuelven los problemas y cómo se estructura un programa. Este curso pretende ayudarte precisamente en eso: a construir una forma de pensar lógica, ordenada y práctica.
Al principio trabajaremos con programas sencillos. Veremos cómo mostrar mensajes por pantalla, cómo pedir datos al usuario, cómo guardar información en variables y cómo tomar decisiones dentro de un programa. Después incorporaremos bucles para repetir acciones, métodos para organizar mejor el código y arrays para trabajar con conjuntos de datos.
Más adelante entraremos en la programación orientada a objetos. En ese momento empezaremos a representar elementos del mundo real mediante clases y objetos. Por ejemplo, podremos crear una clase Alumno, una clase Producto, una clase Coche o una clase Reserva. Cada una tendrá sus propios datos y sus propios comportamientos. Esta forma de programar permite crear aplicaciones más grandes, organizadas y fáciles de mantener.
Al final del curso también veremos una introducción a algunos tipos abstractos de datos, como pilas, colas, listas y una pequeña introducción a grafos. No se trata todavía de estudiarlos con una profundidad matemática avanzada, sino de entender para qué sirven y por qué son importantes en programación.
Este curso requiere práctica. Leer los apuntes ayuda, ver vídeos ayuda, escuchar explicaciones ayuda, pero se aprende a programar programando. Es normal equivocarse, encontrarse errores, no entender algo a la primera o tener que repetir un ejercicio varias veces. Eso forma parte del proceso. Cada error corregido ayuda a mejorar.
El objetivo final es que el alumno no solo sepa escribir pequeños programas en Java, sino que empiece a adquirir una mentalidad de desarrollador: analizar, probar, corregir, mejorar y documentar sus soluciones.
2. Qué es programar
Programar es darle instrucciones a un ordenador para que realice una tarea. Dicho así parece algo sencillo, pero detrás de esa idea hay una habilidad muy importante: saber transformar un problema en una serie de pasos claros, ordenados y precisos.
Un ordenador no interpreta las cosas como una persona. Las personas somos capaces de entender frases incompletas, deducir información por contexto o improvisar soluciones. Un ordenador, en cambio, necesita instrucciones concretas. Si una instrucción está mal escrita, si falta un paso o si el orden no es correcto, el programa no funcionará como esperamos.
Por ejemplo, imaginemos que queremos explicar a una persona cómo preparar un café. Podríamos decirle: “hazme un café”. Si esa persona sabe usar la cafetera, probablemente entenderá lo que queremos. Pero si tuviéramos que explicárselo a un ordenador o a una máquina completamente automática, tendríamos que ser mucho más precisos.
Tendríamos que indicar pasos como comprobar si hay agua, comprobar si hay café, encender la máquina, colocar el vaso, esperar a que termine el proceso y apagarla. Programar consiste precisamente en eso: describir un proceso de forma tan clara que una máquina pueda ejecutarlo.
En programación trabajamos constantemente con datos. Un programa puede recibir información, guardarla, modificarla, compararla y mostrar un resultado. Por ejemplo, un programa puede pedir la edad de una persona y decidir si es mayor de edad. También puede calcular el precio total de una compra, comprobar una contraseña, ordenar una lista de nombres o gestionar las reservas de un hotel.
Un programa no suele ser una única instrucción aislada. Normalmente está formado por muchas instrucciones que trabajan juntas. Algunas sirven para guardar información, otras para tomar decisiones, otras para repetir tareas y otras para organizar mejor el código.
Por ejemplo, si queremos hacer un programa que calcule si un alumno ha aprobado, podríamos pensar en algo como esto:
int nota = 7;
if (nota >= 5) { System.out.println("El alumno ha aprobado"); } else { System.out.println("El alumno ha suspendido"); }
Este pequeño ejemplo ya muestra varias ideas importantes. Hay una variable llamada nota, que guarda un valor numérico. Después hay una condición que comprueba si esa nota es mayor o igual que 5. Según el resultado de esa comprobación, el programa muestra un mensaje u otro.
Aunque el código sea corto, ya estamos haciendo algo esencial en programación: tomar una decisión. Los programas reales están llenos de decisiones de este tipo. Una aplicación bancaria decide si una operación es válida o no. Una tienda online decide si hay stock suficiente. Un videojuego decide si un personaje ha perdido vida. Una aplicación de reservas decide si una habitación está disponible.
Programar también implica aprender a dividir los problemas. Cuando un problema es pequeño, se puede resolver de forma directa. Pero cuando el programa crece, necesitamos organizarlo mejor. No podemos escribir todo el código mezclado sin ningún orden. Por eso existen funciones, métodos, clases, paquetes y estructuras que nos ayudan a mantener el programa limpio y comprensible.
Una parte importante de aprender a programar es aceptar que los errores son normales. Cuando un programa falla, no significa necesariamente que seamos malos programando. Significa que hay algo que revisar. Puede ser un error de sintaxis, una variable mal escrita, una condición mal planteada o una lógica incorrecta.
Los errores forman parte del aprendizaje. De hecho, una de las habilidades más importantes de un programador es saber leer errores, buscar la causa y corregirlos. Programar no es escribir código perfecto a la primera. Programar es construir una solución, probarla, detectar problemas y mejorarla.
También es importante entender que programar no es solo escribir código. Antes de escribir una línea, muchas veces hay que pensar. Hay que entender qué se quiere conseguir, qué datos necesitamos, qué pasos hay que seguir y qué resultado esperamos obtener. Si no entendemos el problema, difícilmente podremos resolverlo bien con código.
Por eso, en este curso no solo escribiremos programas. También aprenderemos a analizar ejercicios, plantear soluciones y explicar lo que hace nuestro código. Esa capacidad de razonar es lo que realmente permite avanzar.
3. Qué es Java y para qué se utiliza
Java es un lenguaje de programación creado para desarrollar aplicaciones de forma ordenada, segura y portable. Es uno de los lenguajes más utilizados en el mundo profesional y ha sido durante muchos años una referencia en el desarrollo de software.
Una de las características más importantes de Java es que permite escribir programas que pueden ejecutarse en diferentes sistemas operativos. Un programa Java puede funcionar en Windows, Linux o macOS siempre que el sistema tenga instalado el entorno adecuado para ejecutarlo. Esta idea se suele resumir con la frase: “escribe una vez, ejecuta en cualquier lugar”.
Para conseguir esto, Java no funciona exactamente igual que otros lenguajes que se compilan directamente para un sistema concreto. Cuando escribimos código Java, ese código se compila y se transforma en un formato intermedio llamado bytecode. Ese bytecode se ejecuta sobre la Máquina Virtual de Java, conocida como JVM.
La JVM actúa como una capa intermedia entre nuestro programa y el sistema operativo. Gracias a ella, el mismo programa puede ejecutarse en distintos entornos sin tener que reescribirlo desde cero.
De forma simplificada, el proceso sería el siguiente:
Primero escribimos un archivo con código Java, por ejemplo:
public class HolaMundo { public static void main(String[] args) { System.out.println("Hola, mundo"); } }
Después ese código se compila. Si no hay errores, se genera un archivo intermedio que puede ejecutar la JVM. Finalmente, la máquina virtual interpreta y ejecuta el programa.
Al principio, muchas partes de este código pueden parecer extrañas. Es normal. Todavía no es necesario entenderlo todo en profundidad. Más adelante veremos qué significa public class, qué es main, por qué se usan llaves { } y cómo se organiza un programa Java. Ahora lo importante es quedarse con la idea general: Java nos permite escribir instrucciones que el ordenador puede ejecutar.
Java se utiliza en muchos ámbitos. Uno de los más importantes es el desarrollo de aplicaciones empresariales. Muchas empresas utilizan Java para crear sistemas de gestión, aplicaciones internas, plataformas web, servicios backend, aplicaciones bancarias, herramientas de administración y sistemas que necesitan ser estables y escalables.
También se ha utilizado mucho en el desarrollo de aplicaciones Android. Aunque hoy en día Android también utiliza Kotlin, Java sigue siendo un lenguaje importante en ese ecosistema y muchos proyectos existentes están escritos total o parcialmente en Java.
Otro uso importante de Java está en el desarrollo de aplicaciones web. En este curso empezaremos por los fundamentos del lenguaje, pero más adelante se puede continuar con Java EE, Servlets, JSP, Spring Boot y otras tecnologías relacionadas con el desarrollo de aplicaciones web y servicios.
Java también se utiliza en educación porque permite aprender muy bien los conceptos fundamentales de la programación orientada a objetos. Aunque al principio puede parecer más estricto que otros lenguajes, esa exigencia ayuda a adquirir buenos hábitos. Java obliga a declarar tipos de datos, organizar el código en clases y seguir una estructura clara.
Por ejemplo, en Java una variable debe tener un tipo. Si queremos guardar un número entero, podemos escribir:
int edad = 20;
Si queremos guardar texto, usamos String:
String nombre = "Ana";
Y si queremos guardar un valor verdadero o falso, usamos boolean:
boolean aprobado = true;
Esta forma de trabajar ayuda a entender qué tipo de información estamos manejando en cada momento. El programa sabe que edad es un número, que nombre es texto y que aprobado representa una condición lógica.
Java es un lenguaje orientado a objetos. Esto significa que permite organizar el código utilizando clases y objetos. Una clase puede entenderse como un molde o plantilla. A partir de ese molde podemos crear objetos concretos.
Por ejemplo, podríamos tener una clase Alumno:
public class Alumno { String nombre; int edad; double notaMedia; }
Esa clase describe qué datos puede tener un alumno. Después, en un programa, podríamos crear alumnos concretos con sus propios valores. Esta forma de trabajar se parece bastante a cómo organizamos la realidad: tenemos entidades, características y acciones.
La programación orientada a objetos será una parte muy importante del curso, pero antes de llegar ahí necesitamos dominar la base: variables, operadores, condiciones, bucles, métodos y arrays. Intentar aprender objetos sin entender bien estos conceptos sería como intentar construir una casa sin tener buenos cimientos.
Java también tiene una gran comunidad y muchísima documentación. Esto es importante porque ningún programador trabaja completamente aislado. Cuando aprendemos un lenguaje, necesitamos ejemplos, documentación oficial, foros, librerías y herramientas. Java cuenta con un ecosistema muy amplio, lo que lo convierte en una opción sólida para aprender y para trabajar profesionalmente.
Otra ventaja de Java es que tiene una sintaxis parecida a otros lenguajes muy utilizados, como C#, JavaScript, C++ o PHP en algunos aspectos. Esto significa que, aunque cada lenguaje tiene sus propias características, aprender Java facilita después el aprendizaje de otros lenguajes. Muchos conceptos se repiten: variables, condiciones, bucles, funciones, clases, objetos y estructuras de datos.
En este curso, Java será nuestro medio para aprender programación. No se trata solamente de aprender comandos de Java, sino de usar Java para comprender cómo se construye un programa desde cero. Primero haremos ejercicios pequeños y controlados. Después iremos aumentando la dificultad. Con el tiempo, los programas tendrán más clases, más métodos y más lógica.
El objetivo no es correr, sino avanzar con seguridad. La programación requiere práctica constante, paciencia y una mentalidad de mejora. Java puede parecer exigente al principio, pero precisamente por eso es una herramienta excelente para aprender bien.
Al terminar esta primera parte del curso, el alumno debería ser capaz de leer y escribir programas básicos en Java, entender la estructura de un programa, utilizar variables, condiciones, bucles, métodos, arrays y comenzar a trabajar con clases y objetos. Esa base será imprescindible para continuar después con tecnologías más avanzadas del ecosistema Java.
Después de esa base inicial, el curso avanzará hacia la programación orientada a objetos, uno de los pilares fundamentales de Java. Aprenderemos a diseñar clases, crear objetos, aplicar encapsulación, trabajar con relaciones entre clases, usar herencia, polimorfismo, clases abstractas e interfaces. La idea no es solo aprender la sintaxis del lenguaje, sino entender cómo se piensa y se organiza una aplicación real.
En la parte final se introducen conceptos algo más avanzados relacionados con los tipos abstractos de datos, como pilas, colas, listas y una primera aproximación a los grafos. Estos contenidos servirán como puente hacia una comprensión más profunda de las estructuras que se utilizan en programación y prepararán el camino para cursos posteriores.
Este será el primero de tres grandes módulos. Una vez asentadas las bases de Java, continuaremos con el desarrollo de aplicaciones web mediante Java EE y, posteriormente, con Spring/Spring Boot, donde aplicaremos estos conocimientos en proyectos más completos y cercanos al desarrollo profesional.
Bloque 1 — Introducción al curso y entorno de trabajo
Presentación del curso de programación con Java
Qué es programar
Qué es Java y para qué se utiliza
Instalación del JDK
Instalación de Eclipse
Configuración inicial de Eclipse
Creación del primer proyecto Java
Estructura básica de un programa Java
Primer programa: Hola Mundo
Compilar, ejecutar y corregir errores básicos
Bloque 2 — Primeros conceptos de programación
Algoritmos y pensamiento computacional
Instrucciones y flujo de ejecución
Datos, memoria y variables
Tipos de datos primitivos en Java
Constantes
Conversión de tipos
Entrada de datos por teclado con Scanner
Salida de datos por consola
Comentarios y buenas prácticas iniciales
Errores comunes al empezar a programar
Bloque 3 — Operadores y expresiones
Operadores aritméticos
Operadores de asignación
Operadores relacionales
Operadores lógicos
Incremento y decremento
Prioridad de operadores
Expresiones simples y compuestas
Ejercicios básicos de cálculo
Validación de expresiones
Depuración básica en Eclipse
Bloque 4 — Estructuras condicionales
Toma de decisiones en programación
Condicional if
Condicional if else
Condicionales anidados
Condiciones múltiples
Operadores lógicos en condiciones
Estructura switch
Menús básicos con switch
Validación de datos con condicionales
Ejercicios prácticos de decisiones
Bloque 5 — Bucles y control de flujo
Introducción a los bucles
Bucle while
Bucle do while
Bucle for
Contadores y acumuladores
Bucles anidados
Control de bucles con break
Control de bucles con continue
Validación repetitiva de datos
Ejercicios prácticos con bucles
Bloque 6 — Métodos y organización del código
Qué es un método
Métodos sin parámetros y sin retorno
Métodos con parámetros
Métodos con valor de retorno
Parámetros y argumentos
Variables locales
Alcance de las variables
Sobrecarga de métodos
Organización del código en métodos
Ejercicios prácticos con métodos
Bloque 7 — Arrays y estructuras básicas de datos
Introducción a los arrays
Declaración y creación de arrays
Recorrido de arrays
Carga de datos en arrays
Búsqueda de elementos
Cálculos con arrays
Arrays de cadenas de texto
Arrays multidimensionales
Matrices en Java
Ejercicios prácticos con arrays y matrices
Bloque 8 — Cadenas de texto y clases básicas de Java
La clase String
Métodos principales de String
Comparación de cadenas
Conversión entre texto y números
La clase Math
Números aleatorios con Random
Fechas básicas con Java
Formateo básico de datos
Uso de clases de utilidad
Ejercicios prácticos con cadenas y utilidades
Bloque 9 — Introducción a la programación orientada a objetos
Qué es la programación orientada a objetos
Clases y objetos
Atributos
Métodos
Creación de objetos
Acceso a atributos y métodos
Estado y comportamiento
Diseño básico de clases
Diagramas sencillos de clases
Primeros ejercicios con objetos
Bloque 10 — Constructores, encapsulación y organización de clases
Constructores
Constructor por defecto
Constructores con parámetros
Sobrecarga de constructores
Encapsulación
Modificadores de acceso
Métodos get y set
Uso de this
Separación de clases en archivos
Ejercicios prácticos de encapsulación
Bloque 11 — Relaciones entre clases
Objetos como atributos
Asociación entre clases
Composición
Agregación
Colecciones de objetos usando arrays
Clases principales y clases auxiliares
Diseño de pequeños modelos de datos
Programas con varias clases
Diagramas UML básicos
Proyecto guiado con varias clases
Bloque 12 — Herencia y reutilización de código
Introducción a la herencia
Clases padre y clases hijas
Uso de extends
Herencia de atributos y métodos
Sobrescritura de métodos
Uso de super
Constructores en herencia
Jerarquías de clases
Ventajas y límites de la herencia
Ejercicios prácticos con herencia
Bloque 13 — Polimorfismo, clases abstractas e interfaces
Introducción al polimorfismo
Referencias de tipo padre
Sobrescritura y comportamiento dinámico
Conversión entre tipos de objetos
Clases abstractas
Métodos abstractos
Interfaces
Implementación de interfaces
Diferencias entre clase abstracta e interfaz
Ejercicios prácticos de polimorfismo
Bloque 14 — Gestión de errores y excepciones
Errores de compilación
Errores de ejecución
Errores lógicos
Introducción a las excepciones
Bloque try catch
Captura de varias excepciones
Bloque finally
Lanzamiento de excepciones
Validación robusta de programas
Ejercicios prácticos con excepciones
Bloque 15 — Colecciones básicas de Java
Limitaciones de los arrays
Introducción a las colecciones
ArrayList
Recorrido de colecciones
Búsqueda en colecciones
Eliminación de elementos
Colecciones de objetos
Ordenación básica
Diferencias entre arrays y colecciones
Ejercicios prácticos con ArrayList
Bloque 16 — Proyecto final del curso
Planteamiento del proyecto final
Análisis de requisitos
Diseño de clases
Creación del proyecto en Eclipse
Desarrollo del modelo de datos
Desarrollo de la lógica del programa
Creación de menús por consola
Validación de entradas
Pruebas y corrección de errores
Presentación del proyecto final
Bloque 17 — Introducción a los tipos abstractos de datos
Qué es un tipo abstracto de datos
Diferencia entre estructura lógica y estructura física
Estructuras estáticas
Estructuras dinámicas
Pilas estáticas
Pilas dinámicas
Colas estáticas
Colas dinámicas
Listas enlazadas básicas
Listas simplemente enlazadas
Listas doblemente enlazadas
Comparación entre arrays, listas, pilas y colas
Introducción a los árboles
Introducción a los grafos
Representación básica de grafos
Recorrido básico de grafos
Ejercicios introductorios de tipos abstractos de datos
En este tema vamos a preparar el entorno de trabajo que usaremos durante el curso de programación con Java. Antes de empezar a escribir programas necesitamos instalar dos piezas fundamentales: el JDK, que contiene las herramientas necesarias para compilar y ejecutar programas Java, y Eclipse, que será el entorno de desarrollo desde el que escribiremos, organizaremos y probaremos nuestros proyectos.
Actualmente, Oracle indica que JDK 26 es la versión más reciente de Java y que JDK 25 es la última versión LTS, es decir, una versión de soporte a largo plazo. Para un curso de programación es recomendable trabajar con una versión LTS porque ofrece más estabilidad. También se puede usar JDK 21 LTS si el centro o el profesor quiere mantener compatibilidad con entornos ya instalados.
Eclipse también se mantiene actualizado y la versión Eclipse IDE 2026-03 incluye soporte para Java 25, además de herramientas para Java, Git, Maven y Gradle.
1. Instalación del JDK 📹
Qué es el JDK
Para poder programar en Java necesitamos instalar el JDK, siglas de Java Development Kit. El JDK es el conjunto de herramientas que permite desarrollar aplicaciones Java. Incluye, entre otras cosas, el compilador, la máquina virtual de Java y diferentes utilidades necesarias para trabajar desde consola o desde un entorno de desarrollo como Eclipse.
Es importante distinguir tres conceptos:
Java es el lenguaje de programación.
JVM, o Java Virtual Machine, es la máquina virtual que ejecuta los programas Java.
JDK es el paquete completo para desarrolladores. Incluye la JVM, el compilador y otras herramientas.
Cuando escribimos un programa Java, normalmente lo guardamos en un archivo con extensión .java. Ese archivo contiene código fuente, es decir, código escrito por una persona. Después, el compilador de Java transforma ese archivo en un archivo .class, que contiene bytecode. Ese bytecode será ejecutado por la JVM.
El proceso básico sería este:
Escribimos un archivo llamado HolaMundo.java.
Lo compilamos.
Se genera un archivo llamado HolaMundo.class.
La JVM ejecuta ese archivo compilado.
Qué versión instalar
Para este curso se recomienda instalar una versión LTS de Java. En este momento, la versión recomendada para un entorno nuevo sería JDK 25 LTS, porque Oracle la identifica como la última versión LTS.
También podemos usar Eclipse Temurin, que es una distribución gratuita y muy utilizada del JDK. Adoptium ofrece descargas de Temurin para distintas versiones LTS, incluyendo JDK 25, JDK 21, JDK 17, JDK 11 y JDK 8.
Para el alumno, la recomendación sencilla es:
Instalar JDK 25 LTS, preferiblemente desde Oracle o desde Eclipse Adoptium Temurin.
Instalación en Windows 📹
En Windows podemos instalar el JDK descargando el instalador desde la página oficial. El alumno debe elegir la versión correspondiente a su sistema operativo, normalmente Windows x64 Installer.
Una vez descargado el instalador, se ejecuta y se siguen los pasos del asistente. Lo normal es aceptar la ruta de instalación por defecto. Una ruta habitual puede ser parecida a esta:
C:\Program Files\Java\jdk-25
Después de instalar el JDK, conviene comprobar que Windows reconoce Java desde la terminal.
Para ello, abrimos Símbolo del sistema o PowerShell y escribimos:
java -version
Deberíamos ver una salida parecida a esta:
java version "25..." Java(TM) SE Runtime Environment ... Java HotSpot(TM) 64-Bit Server VM ...
También debemos comprobar que funciona el compilador:
javac -version
El comando java sirve para ejecutar programas Java. El comando javac sirve para compilar archivos .java.
Si java -version funciona pero javac -version no funciona, normalmente significa que no se ha instalado el JDK completo o que la variable PATH no está bien configurada.
Variables de entorno en Windows
En algunos equipos, después de instalar el JDK, Windows no reconoce los comandos java o javac. En ese caso hay que revisar las variables de entorno.
La variable más importante es PATH. Esta variable le dice al sistema operativo en qué carpetas debe buscar los comandos.
La carpeta que debemos añadir al PATH suele ser la carpeta bin del JDK. Por ejemplo:
C:\Program Files\Java\jdk-25\bin
También se puede crear una variable llamada JAVA_HOME, que apunte a la carpeta principal del JDK:
C:\Program Files\Java\jdk-25
Después, en el PATH, se puede añadir:
%JAVA_HOME%\bin
Una vez hecho esto, hay que cerrar y volver a abrir la terminal. Si dejamos abierta la terminal antigua, es posible que no detecte los cambios.
Instalación en macOS
En macOS también podemos instalar el JDK desde Oracle o desde Eclipse Adoptium. Si se descarga desde la web, normalmente obtendremos un archivo .pkg, que se instala siguiendo el asistente.
Una vez instalado, abrimos la aplicación Terminal y comprobamos:
java -version
Y también:
javac -version
Si ambos comandos devuelven una versión, el JDK está instalado correctamente.
En macOS también se puede comprobar qué versiones de Java están instaladas con:
/usr/libexec/java_home -V
Este comando muestra las instalaciones de Java detectadas por el sistema.
Instalación en Linux
En Linux podemos instalar Java desde los repositorios de la distribución o descargarlo desde Oracle/Adoptium.
En Ubuntu o distribuciones basadas en Debian, una instalación sencilla sería:
sudo apt update sudo apt install openjdk-25-jdk
Si la versión 25 no estuviera disponible en los repositorios de la distribución, se puede instalar una versión LTS disponible, como Java 21:
sudo apt update sudo apt install openjdk-21-jdk
Después comprobamos:
java -version javac -version
En Linux también podemos localizar dónde está instalado Java con:
which java which javac
2. Instalación de Eclipse 📹
Qué es Eclipse
Eclipse es un IDE, es decir, un entorno de desarrollo integrado. Un IDE es una aplicación que reúne en un mismo lugar varias herramientas necesarias para programar: editor de código, explorador de proyectos, compilación, ejecución, depuración, resaltado de errores, autocompletado y gestión de librerías.
Podríamos escribir programas Java usando solamente un editor de texto y la terminal, pero para aprender resulta mucho más cómodo utilizar un IDE. Eclipse nos ayuda a detectar errores, organizar los proyectos y ejecutar el programa con un botón.
Para este curso nos interesa especialmente la versión Eclipse IDE for Java Developers, que incluye las herramientas esenciales para programar en Java. La página oficial de Eclipse la describe como una distribución con herramientas para desarrollo Java, cliente Git, editor XML e integración con Maven y Gradle.
Qué versión de Eclipse descargar
Para este curso podemos usar:
Eclipse IDE for Java Developers
Esta versión es suficiente para aprender Java desde cero, trabajar con clases, paquetes, proyectos, consola, depuración y ejercicios de programación.
Más adelante, cuando el alumno avance hacia Java EE, Servlets, JSP, Maven, servidores y aplicaciones web, puede ser interesante instalar:
Eclipse IDE for Enterprise Java and Web Developers
Esta otra versión incluye herramientas adicionales para aplicaciones web, JavaScript, JSP, JPA, Maven, Gradle, Git y desarrollo empresarial.
Para este primer curso básico de Java, con Eclipse IDE for Java Developers es suficiente.
Instalación en Windows
Para instalar Eclipse en Windows, descargamos el instalador desde la página oficial de Eclipse. Una vez descargado, ejecutamos el instalador y seleccionamos:
Eclipse IDE for Java Developers
El instalador preguntará dónde queremos instalar Eclipse. Se puede dejar la ruta por defecto. También nos preguntará qué versión de Java queremos usar. Si el JDK está bien instalado, Eclipse debería detectarlo automáticamente.
Una vez terminado el proceso, podremos iniciar Eclipse desde el menú de inicio o desde el acceso directo creado.
Instalación en macOS
En macOS descargamos Eclipse desde la página oficial. Normalmente obtendremos un archivo .dmg. Lo abrimos y copiamos Eclipse a la carpeta Aplicaciones.
Al abrir Eclipse por primera vez, macOS puede mostrar un aviso de seguridad porque es una aplicación descargada de Internet. Si aparece ese aviso, debemos permitir su ejecución desde los ajustes de seguridad del sistema.
Instalación en Linux
En Linux podemos descargar Eclipse desde su página oficial como archivo comprimido, descomprimirlo y ejecutar el programa. Otra opción es usar el instalador oficial de Eclipse.
Un ejemplo de instalación manual sería:
cd Descargas tar -xzf eclipse-inst-jre-linux64.tar.gz cd eclipse-installer ./eclipse-inst
Después seleccionamos:
Eclipse IDE for Java Developers
Y seguimos el asistente.
3. Configuración inicial de Eclipse 📹
La primera vez que abrimos Eclipse, nos pedirá seleccionar un workspace.
El workspace es la carpeta donde Eclipse guardará nuestros proyectos. Es importante elegir una ubicación ordenada, porque ahí se irán creando todos los ejercicios del curso.
Por ejemplo, podemos crear una carpeta llamada:
CursoJava
En Windows podría estar en:
C:\Users\Alumno\Documents\CursoJava
En macOS o Linux podría estar en:
/home/alumno/CursoJava
O en macOS:
/Users/alumno/CursoJava
Una buena práctica es no guardar los proyectos en carpetas mezcladas con descargas, escritorio lleno de archivos o rutas difíciles de encontrar.
Selección del workspace
Cuando aparezca la ventana de selección de workspace, elegimos la carpeta donde queremos trabajar.
Podemos marcar la opción:
Use this as the default and do not ask again
Esto hará que Eclipse abra siempre ese workspace por defecto.
Si más adelante queremos cambiar de workspace, podemos hacerlo desde:
File > Switch Workspace
Configurar el JDK en Eclipse
Aunque Eclipse suele detectar automáticamente el JDK instalado, conviene revisar la configuración.
Vamos a:
Window > Preferences
En macOS puede aparecer como:
Eclipse > Settings
Después entramos en:
Java > Installed JREs
Aquí deberíamos ver el JDK instalado. Es importante que aparezca un JDK y no solamente un JRE. El JRE sirve para ejecutar programas, pero el JDK incluye también las herramientas de desarrollo.
Si no aparece, podemos añadirlo manualmente con:
Add > Standard VM
Y seleccionamos la carpeta donde está instalado el JDK.
Es recomendable configurar Eclipse para trabajar con UTF-8. Esto evita problemas con tildes, eñes y caracteres especiales.
Vamos a:
Window > Preferences > General > Workspace
Buscamos la opción:
Text file encoding
Y seleccionamos:
UTF-8
Esto es especialmente importante porque en nuestros programas podemos escribir textos como:
System.out.println("Hola, ¿qué tal?");
Si la codificación no está bien configurada, algunos caracteres podrían verse mal.
Configurar el tamaño de letra
Para trabajar cómodamente en clase, especialmente si el profesor proyecta la pantalla, podemos aumentar el tamaño de letra del editor.
La ruta puede variar según la versión, pero normalmente está en:
Window > Preferences > General > Appearance > Colors and Fonts
Después buscamos:
Java > Java Editor Text Font
Y ajustamos el tamaño.
Mostrar números de línea
Los números de línea son muy útiles para corregir errores. Cuando Java muestra un error, normalmente indica en qué línea se ha producido.
Para activar los números de línea:
Window > Preferences > General > Editors > Text Editors
Marcamos:
Show line numbers
A partir de ese momento, el editor mostrará un número al lado de cada línea de código.
4. Creación del primer proyecto Java
Una vez instalado y configurado Eclipse, vamos a crear nuestro primer proyecto.
Un proyecto en Eclipse es una carpeta organizada que contiene nuestros archivos Java, configuraciones y recursos. Para cada bloque de ejercicios podemos crear un proyecto diferente, o bien trabajar con un único proyecto organizado por paquetes.
Para empezar, crearemos un proyecto sencillo.
Vamos a:
File > New > Java Project
Si no aparece directamente, podemos ir a:
File > New > Other > Java > Java Project
En el nombre del proyecto escribimos:
PrimerProyectoJava
Después revisamos que Eclipse esté usando el JDK correcto.
En la parte de configuración del proyecto podemos dejar las opciones por defecto. Eclipse creará una carpeta src, donde escribiremos el código fuente.
Pulsamos:
Finish
Y veremos el proyecto en el panel izquierdo, llamado normalmente Package Explorer.
Crear una clase Java
Dentro del proyecto vamos a crear una clase.
Hacemos clic derecho sobre la carpeta src:
New > Class
En el nombre de la clase escribimos:
HolaMundo
Marcamos la opción:
public static void main(String[] args)
Esta opción hace que Eclipse cree automáticamente el método principal del programa.
Pulsamos:
Finish
Eclipse creará un archivo llamado:
HolaMundo.java
Ese archivo contendrá una estructura parecida a esta:
public class HolaMundo {
public static void main(String[] args) {
}
}
Estructura básica de un programa Java
Antes de escribir nuestro primer programa completo, vamos a entender la estructura mínima de un programa Java.
Un programa Java básico suele estar formado por una clase y un método main.
Ejemplo:
public class HolaMundo {
public static void main(String[] args) { System.out.println("Hola Mundo"); }
}
Vamos a analizarlo poco a poco.
La clase
Esta línea declara una clase:
public class HolaMundo {
En Java, casi todo el código se escribe dentro de clases. La clase es una estructura fundamental del lenguaje. Más adelante, cuando estudiemos programación orientada a objetos, veremos las clases con mucho más detalle.
De momento, podemos pensar que una clase es una especie de contenedor donde escribimos código.
El nombre de la clase es:
HolaMundo
Por norma general, el archivo debe llamarse igual que la clase pública. Por eso, si la clase se llama HolaMundo, el archivo debe llamarse:
HolaMundo.java
Esto es importante. Si el archivo no se llama igual que la clase pública, Java mostrará un error.
Las llaves
En Java se usan llaves { } para delimitar bloques de código.
Por ejemplo:
public class HolaMundo {
}
Todo lo que está dentro de esas llaves pertenece a la clase HolaMundo.
También el método main tiene sus propias llaves:
public static void main(String[] args) {
}
Todo lo que escribamos dentro de esas llaves será parte del método principal.
Uno de los errores más comunes al empezar es borrar una llave sin querer o colocarla en un sitio incorrecto. Cuando esto ocurre, Eclipse suele marcar errores en varias líneas, aunque el problema real sea una sola llave mal colocada.
El método main
El método main es el punto de entrada del programa. Cuando ejecutamos una aplicación Java, Java busca este método para saber por dónde debe empezar.
La estructura es:
public static void main(String[] args) {
}
Al principio no hace falta memorizar cada palabra, pero sí debemos acostumbrarnos a reconocerlo. Durante las primeras clases lo usaremos constantemente.
Podemos verlo como la puerta de entrada del programa.
Cuando damos al botón de ejecutar, Java entra en el método main y empieza a ejecutar las instrucciones que hay dentro, de arriba abajo.
Instrucciones
Dentro del método main escribimos instrucciones.
Por ejemplo:
System.out.println("Hola Mundo");
Esta instrucción muestra un texto por pantalla, concretamente en la consola de Eclipse.
La instrucción termina con punto y coma:
;
En Java, muchas instrucciones terminan con punto y coma. Olvidar el punto y coma es uno de los errores más habituales al empezar.
Comentarios
Los comentarios son partes del código que Java ignora. Sirven para dejar explicaciones para nosotros o para otros programadores.
Comentario de una línea:
// Esto es un comentario de una línea
Comentario de varias líneas:
/* Esto es un comentario de varias líneas */
Ejemplo completo:
public class HolaMundo {
public static void main(String[] args) { // Mostramos un mensaje por pantalla System.out.println("Hola Mundo"); }
}
Los comentarios son útiles, pero no conviene abusar de ellos. Un buen comentario explica algo que no es evidente, no repite lo mismo que ya dice el código.
6. Primer programa: Hola Mundo
El primer programa tradicional en casi cualquier lenguaje de programación es Hola Mundo. Es un programa muy sencillo que sirve para comprobar que el entorno está bien instalado y que somos capaces de crear, compilar y ejecutar código.
Nuestro programa será este:
public class HolaMundo {
public static void main(String[] args) { System.out.println("Hola Mundo"); }
}
Cuando lo ejecutemos, veremos en la consola:
Hola Mundo
Aunque parezca un programa muy simple, aquí ya están apareciendo varias ideas importantes:
Estamos creando una clase.
Estamos usando el método principal main.
Estamos escribiendo una instrucción.
Estamos mostrando información por consola.
Estamos usando comillas para escribir texto.
Estamos terminando la instrucción con punto y coma.
Estamos ejecutando un programa Java real.
Mostrar varios mensajes
Podemos escribir más de una instrucción:
public class HolaMundo {
public static void main(String[] args) { System.out.println("Hola Mundo"); System.out.println("Estoy aprendiendo Java"); System.out.println("Este es mi primer programa"); }
}
La salida será:
Hola Mundo Estoy aprendiendo Java Este es mi primer programa
Java ejecuta las instrucciones en orden, desde la primera hasta la última.
Diferencia entre println y print
System.out.println muestra un texto y después hace un salto de línea.
Vamos a hacer un programa que muestre una pequeña ficha del alumno:
public class FichaAlumno {
public static void main(String[] args) { System.out.println("===== FICHA DEL ALUMNO ====="); System.out.println("Nombre: Antonio"); System.out.println("Curso: Programación con Java"); System.out.println("Editor: Eclipse"); System.out.println("Lenguaje: Java"); System.out.println("============================"); }
}
Salida:
===== FICHA DEL ALUMNO ===== Nombre: Antonio Curso: Programación con Java Editor: Eclipse Lenguaje: Java ============================
Este ejemplo sigue siendo muy básico, pero ya nos permite practicar la escritura de instrucciones, el uso de textos y la ejecución de programas.
7. Compilar, ejecutar y corregir errores básicos
Qué significa compilar
Compilar es transformar el código fuente que hemos escrito en un formato que pueda ejecutar la máquina virtual de Java.
El archivo que escribimos nosotros tiene extensión:
.java
Por ejemplo:
HolaMundo.java
Al compilarlo, Java genera un archivo con extensión:
.class
Por ejemplo:
HolaMundo.class
Ese archivo .class contiene bytecode, que será ejecutado por la JVM.
En Eclipse, normalmente no tenemos que compilar manualmente. Eclipse compila automáticamente cada vez que guardamos el archivo, siempre que la opción de construcción automática esté activada.
Podemos comprobarlo en:
Project > Build Automatically
Lo normal es dejar esta opción activada.
Ejecutar un programa en Eclipse
Para ejecutar un programa Java en Eclipse, abrimos la clase que contiene el método main.
Después podemos pulsar el botón verde de ejecutar, con forma de play.
También podemos hacer clic derecho sobre el archivo y elegir:
Run As > Java Application
Si todo está correcto, la salida aparecerá en la pestaña Console.
Por ejemplo, si ejecutamos:
public class HolaMundo {
public static void main(String[] args) { System.out.println("Hola Mundo"); }
}
Veremos:
Hola Mundo
Ejecutar desde consola
Aunque durante el curso trabajaremos principalmente con Eclipse, conviene entender cómo se ejecutaría un programa desde consola.
Supongamos que tenemos este archivo:
HolaMundo.java
Con este contenido:
public class HolaMundo {
public static void main(String[] args) { System.out.println("Hola Mundo desde consola"); }
}
Para compilarlo desde terminal:
javac HolaMundo.java
Si no hay errores, se generará:
HolaMundo.class
Para ejecutarlo:
java HolaMundo
Importante: al ejecutar no escribimos .class.
Correcto:
java HolaMundo
Incorrecto:
java HolaMundo.class
La salida será:
Hola Mundo desde consola
8. Errores básicos al empezar con Java
Cuando empezamos a programar, los errores son normales. No significan que lo estemos haciendo mal. Significan que estamos aprendiendo a comunicarnos con el lenguaje.
Lo importante es aprender a leer el error, localizar la línea y corregirlo con calma.
Error 1: olvidar el punto y coma
Código incorrecto:
public class HolaMundo {
public static void main(String[] args) { System.out.println("Hola Mundo") }
}
El problema está aquí:
System.out.println("Hola Mundo")
Falta el punto y coma al final.
Código correcto:
public class HolaMundo {
public static void main(String[] args) { System.out.println("Hola Mundo"); }
}
En Java, muchas instrucciones terminan con ;. Si falta, Eclipse marcará un error de sintaxis.
Error 2: escribir mal System
Código incorrecto:
public class HolaMundo {
public static void main(String[] args) { system.out.println("Hola Mundo"); }
}
El problema es que hemos escrito system con minúscula.
En Java se distinguen mayúsculas y minúsculas. No es lo mismo:
System
Que:
system
Código correcto:
public class HolaMundo {
public static void main(String[] args) { System.out.println("Hola Mundo"); }
}
Este concepto se llama case sensitive. Java diferencia entre mayúsculas y minúsculas en nombres de clases, variables, métodos y palabras del lenguaje.
Error 3: olvidar las comillas en un texto
Código incorrecto:
public class HolaMundo {
public static void main(String[] args) { System.out.println(Hola Mundo); }
}
El texto debe ir entre comillas dobles.
Código correcto:
public class HolaMundo {
public static void main(String[] args) { System.out.println("Hola Mundo"); }
}
Cuando escribimos texto literal, usamos comillas dobles:
"Hola Mundo"
Error 4: nombre de clase y archivo diferentes
Supongamos que el archivo se llama:
HolaMundo.java
Pero dentro escribimos:
public class PrimerPrograma {
public static void main(String[] args) { System.out.println("Hola Mundo"); }
}
Esto dará error porque la clase pública se llama PrimerPrograma, pero el archivo se llama HolaMundo.java.
En Java, si una clase es pública, el archivo debe llamarse igual.
Solución 1: cambiar el nombre de la clase:
public class HolaMundo {
public static void main(String[] args) { System.out.println("Hola Mundo"); }
}
Solución 2: cambiar el nombre del archivo a:
PrimerPrograma.java
Error 5: borrar una llave
Código incorrecto:
public class HolaMundo {
public static void main(String[] args) { System.out.println("Hola Mundo");
}
Falta una llave de cierre. Tenemos una llave para abrir la clase y otra para abrir el método main, pero solo una llave de cierre.
Código correcto:
public class HolaMundo {
public static void main(String[] args) { System.out.println("Hola Mundo"); }
}
Una buena costumbre es escribir las llaves de forma ordenada y tabular bien el código. Eclipse puede ayudarnos con el formateo automático.
Podemos usar:
Source > Format
O el atajo habitual:
Ctrl + Shift + F
En macOS puede variar según la configuración del teclado.
Error 6: ejecutar la clase equivocada
A veces tenemos varias clases en el proyecto y ejecutamos una clase que no es la que queremos probar.
Por ejemplo, tenemos:
HolaMundo.java FichaAlumno.java Prueba.java
Si estamos editando FichaAlumno.java, pero Eclipse ejecuta HolaMundo.java, veremos una salida que no corresponde con el código que acabamos de cambiar.
Para evitarlo, hacemos clic derecho sobre la clase que queremos ejecutar:
Run As > Java Application
Así nos aseguramos de ejecutar el archivo correcto.
Error 7: no tener método main
Código:
public class HolaMundo {
System.out.println("Hola Mundo");
}
Este código es incorrecto porque la instrucción está directamente dentro de la clase, pero no dentro del método main.
Código correcto:
public class HolaMundo {
public static void main(String[] args) { System.out.println("Hola Mundo"); }
}
En estos primeros programas, las instrucciones deben estar dentro del método main.
9. Ejercicios propuestos
Ejercicio 1: primer mensaje
Crea un proyecto llamado:
EjerciciosPrimerosPasos
Dentro del proyecto, crea una clase llamada:
Ejercicio01
El programa debe mostrar por pantalla:
Estoy aprendiendo Java con Eclipse
Solución orientativa:
public class Ejercicio01 {
public static void main(String[] args) { System.out.println("Estoy aprendiendo Java con Eclipse"); }
}
Ejercicio 2: ficha personal
Crea una clase llamada:
Ejercicio02
El programa debe mostrar una ficha con tu nombre, curso y lenguaje que estás aprendiendo.
Ejemplo de salida:
Nombre: Laura Curso: Programación Lenguaje: Java Editor: Eclipse
public static void main(String[] args) { System.out.print("Hola "); System.out.print("Java"); System.out.println(); System.out.println("Fin del programa"); }
}
Salida esperada:
Hola Java Fin del programa
Observa que print no cambia de línea, mientras que println sí lo hace.
Ejercicio 5: provocando errores
Crea una clase llamada:
Ejercicio05
Escribe el programa Hola Mundo, pero provoca intencionadamente estos errores de uno en uno:
Quita el punto y coma.
Cambia System por system.
Quita una comilla.
Borra una llave.
Cambia el nombre de la clase.
Después observa qué error muestra Eclipse y corrígelo.
Este ejercicio es importante porque ayuda a perder el miedo a los errores. Un programador no es alguien que nunca se equivoca. Un programador es alguien que aprende a leer, entender y corregir errores.
10. Resumen del tema
En este tema hemos preparado el entorno básico para empezar a programar con Java. Hemos instalado el JDK, que contiene las herramientas necesarias para compilar y ejecutar programas Java. También hemos instalado Eclipse, que será nuestro entorno de desarrollo durante el curso.
Después hemos configurado el workspace, revisado el JDK dentro de Eclipse, activado opciones útiles como la codificación UTF-8 y los números de línea, y hemos creado nuestro primer proyecto Java.
También hemos visto la estructura mínima de un programa Java: una clase, el método main y una o varias instrucciones. Con el programa Hola Mundo hemos comprobado que todo funciona correctamente.
Por último, hemos repasado errores básicos muy habituales: olvidar el punto y coma, escribir mal las mayúsculas, borrar llaves, no poner comillas o ejecutar la clase equivocada.
A partir de aquí ya podemos empezar a trabajar con los primeros conceptos de programación: variables, tipos de datos, operadores, entrada de datos y estructuras de control.
