Cargando página...

Cursos disponibles

Entra directo al temario, descargas y practica guiada. Si empiezas desde cero, empieza por Web.

Curso Básico de Java

Aprende desde cero estructuras, funciones, clases y más.

Ir al curso
Curso de Iniciación Web

Aprende a crear tus primeras páginas web desde cero.
Ideal para comenzar en la programación con teoría clara, prácticas interactivas y descargas.

Empezar ahora
Curso de Python

Aprende desde cero con teoría explicada, editor en vivo y archivos descargables (.py y .md)

Entrar al curso
Java desde Cero · Teoría y Práctica

Teoría completa, prácticas guiadas, tests interactivos y proyecto final.

Ir al curso
Curso de Git y GitHub

Control de versiones, ramas, commits y repositorios.

Ir al curso
Curso de Bases de Datos

Consultas SQL, modelos relacionales y prácticas.

Ir al curso

Impacto de la plataforma

Aprendizaje real con práctica guiada y asistencia de IA

0+

Alumnos formados

0+

Horas impartidas

0+

Ejercicios prácticos

0+

Ejercicios con IA

0%

Satisfacción

Curso Web de Iniciación

De cero a publicar tu primera web en Netlify

HTML
Estructura y etiquetas
CSS
Estilos y diseño
JavaScript
Interactividad
Bootstrap
Componentes
UT1 HTML UT2 CSS UT3 Bootstrap UT4 JS UT5 IA UT6 Netlify

Objetivo: preparar tu ordenador para crear páginas web. Solo necesitas VS Code (editor gratuito) y Live Server (extensión para ver tu web).
1
Instala VS Code

Descarga e instala Visual Studio Code desde su web oficial.

Descargar VS Code
2
Instala Live Server

Abre VS Code → Extensiones (Ctrl+Shift+X) → Busca "Live Server" → Instalar.

Extensión gratuita
3
Abre tu archivo .html

Descarga un .html del curso → Abre con VS Code → Clic derecho → Open with Live Server.

Se abre en el navegador
Cómo usar los materiales del curso
  1. Descarga el archivo .html de la unidad que quieras practicar.
  2. Abre VS Code y arrastra el archivo o usa Archivo → Abrir.
  3. Clic derecho en el código → Open with Live Server.
  4. Edita el código y guarda (Ctrl+S). La página se actualiza sola.
  5. Experimenta: cambia colores, textos, añade cosas. ¡Así se aprende!
Checklist antes de empezar
  • VS Code instalado
  • Extensión Live Server instalada
  • Sabes abrir un .html con Live Server
  • ¡Listo para la Unidad 1!
Descargar guía (.md)

Objetivo: comprender la estructura base de un documento HTML5 y usar etiquetas semánticas para construir páginas claras, accesibles y fáciles de mantener.

Trabajaremos directamente en el código con una clase .html comentada (estilo Better Comments) y una plantilla rellenable para que el alumno construya su primera página paso a paso. La guía .md resume teoría y propone ejercicios cortos.

  • 📌 Estructura básica: Todo documento HTML empieza con <!DOCTYPE html>, seguido de la etiqueta raíz <html lang="es">. Dentro, el <head> contiene metadatos (ej. <meta charset="UTF-8">, <meta name="viewport"> para móviles) y el <title>. El contenido visible se coloca en <body>.
  • 🧭 Secciones semánticas: Para que el navegador y lectores de pantalla entiendan la página, usamos etiquetas con significado: <header> (cabecera), <nav> (menú), <main> (contenido principal), <section> (bloques temáticos), <article> (artículos o posts) y <footer> (pie de página).
  • 📝 Contenido: HTML organiza la información con títulos h1–h6, párrafos <p>, enlaces <a>, listas <ul>/<ol> con <li>, e imágenes <img> (siempre con atributo alt).
  • 🔗 Navegación interna: Puedes crear enlaces que lleven a distintas partes de la misma página usando anclas: <a href="#id">. Esto sirve para construir un menú simple que “salta” a cada sección.
  • Accesibilidad básica: Es importante mantener una jerarquía clara de títulos (un solo <h1> y luego h2/h3 en orden), poner texto alternativo a las imágenes y usar atributos como aria-label o aria-labelledby cuando sea necesario para que todos los usuarios puedan navegar sin problemas.
UT1_Clase_HTML_Completa.html
⏳ Cargando código...
Descargar Clase (.html) Descargar Plantilla (.html) Guía teórica (.md)

Objetivo: entender cómo estilizar tu HTML con CSS, empezando por estilos globales, colores, tipografía y modelo de caja; aplicarlo a un portfolio simple y dejarlo listo para maquetaciones posteriores.

Trabajaremos directamente en el código con una clase .html comentada (Better Comments) y una plantilla rellenable para practicar. La guía .md resume teoría y propone ejercicios rápidos.

  • 🎛️ Estilos globales: Lo primero al empezar con CSS es definir la base de la página: una fuente clara, un color de fondo y un color de texto. También se aplican pequeños “reseteos” para que todos los navegadores muestren el diseño igual.
  • 🎨 Colores: Con las propiedades color y background-color decides la paleta de tu web. Un buen contraste entre texto y fondo hace que la lectura sea más cómoda y accesible.
  • 🔤 Tipografía: CSS te permite elegir la font-family (fuente), controlar el tamaño del texto, hacerlo más grueso o más fino, y usar unidades como px o rem para mantener consistencia en diferentes pantallas.
  • 📦 Modelo de caja: Cada elemento HTML se comporta como una “caja” que puedes personalizar con margin (espacio externo), padding (espacio interno), border (bordes) y box-shadow (sombras). Entender esto es clave para controlar bien el diseño.
  • 🧭 Navegación y utilidades: Aprenderás a dar estilo a menús simples y a crear pequeñas clases de utilidad para alinear, centrar o espaciar elementos sin repetir mucho código.
  • 🧪 Mini-proyecto: Pondrás en práctica todo lo anterior aplicando CSS a tu portfolio de UT1: darle colores, tipografías y una estructura visual coherente para que se convierta en una página atractiva.
UT2_Clase_CSS_Completa.html
⏳ Cargando código...
Descargar Clase (.html) Descargar Plantilla (.html) Guía teórica (.md)

Objetivo: maquetar y estilizar rápido tu portfolio con Bootstrap 5 usando container, grid, utilidades y componentes esenciales (navbar, botones, formularios, tablas, alertas, carrusel, cards).

Trabajaremos con una clase .html y una plantilla rellenable para aplicar Bootstrap al portfolio de UT1/UT2. La guía .md resume teoría y propone ejercicios cortos.

  • 🔧 ¿Qué es Bootstrap? Es un kit de herramientas que te permite dar estilo y maquetar páginas web sin tener que escribir CSS desde cero. Lo cargas con un enlace (CDN) y ya puedes usarlo.
  • 📦 Diseño rápido y ordenado Bootstrap trae un sistema de contenedores, tipografías limpias y utilidades de espaciado que ayudan a que tu página se vea profesional desde el primer minuto.
  • 🧱 Grid de 12 columnas Su “rejilla” hace que tu página sea responsiva automáticamente: el contenido se adapta a móvil, tablet o PC sin esfuerzo, solo usando clases ya preparadas.
  • 🟦 Componentes listos para usar Menús de navegación, botones, formularios, tablas, alertas, tarjetas y hasta carruseles de imágenes. Todo con un estilo consistente y bonito, listo para personalizar.
  • 🗂️ Cards para proyectos Son bloques visuales que combinan imagen + texto + botón. Perfectas para mostrar tus trabajos, productos o ideas sin tener que inventar el diseño.
  • 🚀 ¿Por qué usarlo en tu portfolio? Porque con muy poco código consigues que tu página se vea como una web moderna y profesional. Lo que en CSS manual te llevaría horas, aquí lo tienes en minutos.
UT3_Clase_BOOSTRAP_Completa.html
⏳ Cargando código...
Descargar Clase (.html) Descargar Plantilla (.html) Guía teórica (.md)

Objetivo: dar vida a tu página con JavaScript: escuchar acciones del usuario, manipular el DOM y mostrar mensajes dinámicos sin recargar.

Trabajaremos con una clase .html comentada y una plantilla rellenable para integrar JS en el portfolio de UT1/UT2/UT3. La guía .md resume teoría y propone ejercicios rápidos.

  • 🧠 ¿Qué es JavaScript? El lenguaje que hace tu web interactiva: responder a clics, escribir en la página, mostrar/ocultar cosas y actualizar datos sin recargar.
  • 🔌 ¿Dónde va el JS? Dentro de <script> en el HTML o en un archivo externo .js enlazado. Ideal: separar el JS en su propio archivo para mantener el código limpio.
  • 🎛️ Eventos Acciones del usuario como click, input o submit. Con addEventListener “escuchas” esas acciones y ejecutas una función.
  • 🧩 DOM El árbol de elementos de tu página. Con document.querySelector seleccionas un elemento y con textContent, classList o setAttribute lo modificas.
  • 📨 Formularios Valida datos, evita envíos vacíos con event.preventDefault() y muestra feedback visual (mensajes de éxito o error).
  • 🚀 Mini-proyecto Añadir interacción al portfolio: botón que cambia textos, contador de clics, vista previa de un campo de texto y validación simple del formulario de contacto.
UT4_Clase_JAVASCRIPT_Completa.html
⏳ Cargando código...
Descargar Clase (.html) Descargar Plantilla (.html) Guía teórica (.md)

Objetivo: cerrar el curso con un portfolio completo combinando UT1–UT4 (HTML, CSS, Bootstrap, JS) y usar IA para mejorar textos, accesibilidad y microdetalles antes de publicar.

Trabajaremos con una clase .html y una plantilla rellenable listas para usar. La guía .md explica cada bloque (tema claro/oscuro, filtro de proyectos, galería con modal, validación de formulario y pequeños retoques de UI).

  • 🌗 Tema claro/oscuro Usa variables CSS y el atributo data-theme en <body>. La preferencia del usuario se guarda en localStorage para recordar el modo.
  • 🧱 Maquetación Bootstrap Navbar fija, hero con CTA, grid responsive de “Proyectos” y utilidades de espaciado/colores coherentes.
  • 🔎 Filtro de proyectos Búsqueda en vivo por palabra clave leyendo data-tags, título y descripción de cada card.
  • 🖼️ Galería Imágenes que abren un modal a pantalla grande. Sin JS extra: basta con el bundle de Bootstrap.
  • ✉️ Formulario Validación con Bootstrap + JS: mensajes claros de éxito/error y reset automático al enviar.
  • 🚀 Remate con IA Pulir microcopys, atributos alt y aria-*, contrastes y CTA. Además, detectar mejoras rápidas de UX, SEO y rendimiento.
UT5_Clase_Final_IA.html
⏳ Cargando código...
Descargar Clase (.html) Descargar Plantilla (.html) Guía teórica (.md) Guía de plantilla (.md)

Objetivo: publicar tu primera página web y obtener un enlace para compartir (portfolio, trabajo de clase o proyecto final).
✅ Pasos (modo rápido)
  1. Crea una carpeta en tu PC (por ejemplo mi-web).
  2. Dentro debe existir un archivo llamado index.html (es el “inicio” de tu web).
  3. Prueba en local: abre index.html o usa Live Server en VS Code.
  4. Entra en Netlify Drop y arrastra la carpeta (o el index.html).
  5. Netlify te da una URL: abre el enlace, revisa y compártelo.
Errores típicos: el archivo no se llama index.html, rutas rotas a imágenes/CSS (carpetas distintas), o enlaces con espacios sin codificar.
Enlaces útiles

Más adelante, para un despliegue “pro” (que se actualice solo al cambiar tu código), conecta tu proyecto a GitHub. Para empezar, Drop es perfecto.

Descargar guía (.md) Descargar plantilla (.html)
Entrega recomendada: sube tu web, copia la URL, y envíala junto con 3 capturas (móvil, tablet y escritorio).

Opcional pero recomendado: aprende a depurar con DevTools (F12) y a versionar tu código con Git.
DevTools (F12)
  • Elements: inspeccionar y editar HTML/CSS en vivo.
  • Console: ver errores de JavaScript y probar código.
  • Network: analizar peticiones.
  • Responsive: probar en móvil/tablet.
Git Básico
  • git init — Iniciar repositorio.
  • git add . — Preparar cambios.
  • git commit -m "msg" — Guardar versión.
  • git push — Subir a GitHub.
Pro tip: con Git + GitHub, Netlify actualizará tu web automáticamente con cada git push.

Selecciona una fase para ver el ejemplo y las indicaciones. Cuando lo necesites, abre el editor en ventana embebida (compacta y redimensionable) o en ventana emergente.

Editor Code
Abrir en CodePen

Curso Java: guía y descargas

Herramientas necesarias para el curso

Java es un lenguaje muy usado en DAW/DAM y en empresas. En este curso vas a aprender desde lo básico (variables, condicionales, bucles) hasta POO y proyecto final.

Objetivo: dejar listo el entorno en 10 minutos para poder compilar y ejecutar sin líos.
Paso 1 · Instalar Java (JDK)

Instala JDK 17 o superior. Recomendado: Temurin (Adoptium), que se instala con asistente (siguiente, siguiente...).

Descargar Temurin JDK
Elige: Windowsx64JDK 17.msi.
Paso 2 · Editor recomendado

Usa Visual Studio Code para abrir los archivos del curso y trabajar cómodo.

Descargar VS Code
Consejo: abre una carpeta del proyecto (no archivos sueltos).
Extensiones recomendadas (VS Code)
  • Java Extension Pack: compilar, ejecutar y depurar Java.
  • Better Comments: mejora la lectura de comentarios.
Los archivos .java son el código fuente. Las guías .md explican teoría y tareas. Puedes abrir ambos en VS Code sin problemas.

En esta primera unidad verás los fundamentos de Java para empezar con buen pie: cómo declarar variables, cuáles son los tipos de datos más usados y cómo operar con ellos mediante operadores aritméticos, de comparación y lógicos. Todo con ejemplos sencillos y buenas prácticas para evitar errores típicos.

  • 📌 Tipos primitivos y para qué se usan: int (enteros), double (decimales), boolean (verdadero/falso) y char (carácter).
  • 🧮 Operadores aritméticos: + - * / %. Comparación: == != < <= > >=. Lógicos: && (y), || (o), ! (no).
  • 📝 Buenas prácticas: nombres en camelCase (precioTotal), evita abreviaturas confusas, inicializa variables, usa final para constantes y comenta lo imprescindible.
  • Objetivo: al terminar, podrás declarar variables, combinarlas en expresiones y decidir el tipo correcto para cada dato.
Descargar código .java Descargar guía .md

En esta unidad aprenderás a tomar decisiones en tus programas controlando el flujo de ejecución. Verás cómo usar if, else y switch para actuar en función de ciertas condiciones, y cómo combinar varias usando operadores lógicos como && y ||.

  • 🔀 Condiciones simples y múltiples con if, if/else y else if para controlar casos diferentes.
  • 📋 Decisiones por casos usando switch y case para elegir entre múltiples opciones.
  • 🧠 Operadores lógicos: && (y), || (o), ! (no) para combinar o invertir condiciones.
  • 💡 Buenas prácticas: evita anidar demasiados if, usa sangrías claras y considera switch para casos múltiples.
  • Objetivo: al final podrás crear programas que respondan de forma diferente según la información o las acciones del usuario.

En esta unidad aprenderás a repetir instrucciones de forma automática usando bucles. Veremos cómo aplicar for, while y do while en diferentes situaciones reales, con ejercicios prácticos como contadores, validaciones y menús.

  • 🔁 Bucle for: ideal para repeticiones controladas
  • 🔄 Bucle while: se ejecuta mientras se cumple una condición
  • 🔂 Bucle do while: siempre se ejecuta al menos una vez
  • ✅ Ejercicios con bucles anidados y control de flujo

En esta unidad aprenderás a reutilizar código mediante funciones. Verás cómo declarar métodos, pasarles parámetros y devolver resultados. También aprenderás a modularizar programas y mejorar su mantenimiento.

  • 🔧 Declaración de funciones con parámetros
  • ↩️ Métodos que devuelven valores
  • 🧩 Modularización y reutilización del código
  • 💡 Ejemplos con funciones prácticas y organizadas

Esta unidad abarca todos los pilares de la programación orientada a objetos en Java. Aprenderás a construir clases con sus atributos y métodos, crear objetos a partir de ellas, y reutilizar código mediante herencia. También explorarás cómo sobrescribir métodos y usar interfaces para diseñar estructuras flexibles y escalables.

  • 🏗️ Definición de clases, atributos y métodos
  • 🔁 Instanciación de objetos con new y acceso a métodos
  • 🧬 Herencia con extends y uso de super
  • 🧠 Polimorfismo y sobreescritura de métodos (@Override)
  • 🔌 Uso de interfaces para definir comportamientos comunes
  • 📘 Guía disponible: solo para Clases y Objetos

En esta unidad aprenderás a detectar, controlar y gestionar errores en tiempo de ejecución. Usarás bloques try, catch, finally y también podrás lanzar tus propias excepciones con throw.

  • ⚠️ Gestión de errores con try/catch/finally
  • 🎯 Excepciones predefinidas y personalizadas
  • 🚫 Uso de throw y throws
  • 📘 Guía explicativa con teoría y ejercicios

En esta unidad aprenderás a trabajar con textos en Java: cómo manipular cadenas, extraer información, reemplazar partes de un texto y aplicar métodos útiles de la clase String como length, substring, split, etc.

  • ✂️ Cortar y unir textos (substring, concat)
  • 🔎 Búsquedas con contains, indexOf y replace
  • 🔠 Conversión entre mayúsculas y minúsculas
  • 📘 Guía práctica con teoría y ejercicios resueltos

En esta unidad trabajarás con estructuras de datos básicas como arrays unidimensionales y bidimensionales, y aprenderás a manipular texto con cadenas. Es ideal para afianzar el uso de bucles con estructuras de datos y operaciones comunes sobre arrays y String.

  • 📌 Declaración e inicialización de arrays
  • 🔁 Recorrido con bucles for y foreach
  • 🧩 Operaciones básicas con strings: cortar, unir, buscar
  • 📘 Incluye ejercicios combinando arrays y cadenas de texto

En esta unidad aprenderás a utilizar herramientas potentes de análisis y transformación de texto. Dominarás funciones avanzadas de String y comenzarás a trabajar con expresiones regulares (regex) para búsquedas, validaciones y reemplazos complejos.

  • 🧠 Métodos avanzados de String: matches, split, replaceAll
  • 🧪 Introducción a expresiones regulares
  • ✅ Ejemplos de validación de correos, DNI, contraseñas
  • 📘 Guía con teoría, patrones y ejercicios prácticos

Esta unidad combina operaciones matemáticas útiles y el tratamiento de fechas y horas en Java. Aprenderás a utilizar Math para cálculos y LocalDate / LocalTime para gestionar el tiempo.

  • 🧮 Métodos comunes de Math: sqrt, pow, random, abs...
  • 📆 Gestión de fechas con LocalDate
  • ⏰ Trabajo con LocalTime y Duration
  • 📘 Guía con ejercicios prácticos y ejemplos explicados

Esta unidad profundiza en el uso de expresiones regulares para validar y analizar textos de forma eficiente. Aprenderás a crear patrones para detectar formatos como correos, DNI, contraseñas, fechas y más.

  • 🔤 Sintaxis básica de regex: [a-z], \\d, +, *, {n}...
  • ✅ Validaciones reales (correo, DNI, nombre, fecha...)
  • 🔎 Métodos clave: matches, replaceAll, split
  • 📘 Guía con ejemplos resueltos y ejercicios paso a paso

En esta unidad aprenderás a trabajar con archivos en Java, tanto para leer información como para escribirla. Utilizarás clases como File, FileReader, BufferedReader, PrintWriter, etc.

  • 📂 Lectura de archivos línea a línea
  • 📝 Escritura y creación de archivos de texto
  • 🚫 Manejo de excepciones en operaciones con ficheros
  • 📘 Incluye guía con ejemplos prácticos y tareas

Esta unidad profundiza en el uso de las colecciones de Java como List, Set y Map. Aprenderás a utilizar implementaciones como ArrayList, HashSet y HashMap para almacenar y manipular datos dinámicos.

  • 📋 Listas dinámicas con ArrayList
  • 📦 Conjuntos sin duplicados con HashSet
  • 🔑 Asociación clave-valor con HashMap
  • 📘 Ejercicios prácticos para organizar datos y acceder eficientemente a ellos

En esta unidad aprenderás a declarar constantes de forma segura y estructurada con enum, así como a definir constantes simbólicas mediante static final. Estos conceptos son fundamentales para evitar errores y mejorar la legibilidad del código.

  • 🔢 Declaración y uso de enumeraciones con enum
  • 🔒 Creación de constantes con static final
  • 📚 Casos de uso reales: días de la semana, estados, menús
  • 📘 Guía clara con teoría, ejemplos y ejercicios prácticos

En esta unidad aprenderás a dividir tus proyectos Java en archivos organizados y reutilizables mediante el uso de paquetes. También verás cómo importar clases desde otros archivos y trabajar con estructuras modulares en aplicaciones grandes.

  • 📦 Creación de paquetes personalizados (package)
  • 🔁 Importación de clases con import
  • 🧩 Organización lógica del código para proyectos medianos y grandes
  • 📘 Guía completa con teoría, buenas prácticas y ejercicios

En esta última unidad aplicarás todos los conocimientos adquiridos a lo largo del curso desarrollando un proyecto completo en Java: un gestor de alumnos con menús, almacenamiento de datos, estructuras condicionales, bucles, colecciones y manejo de errores.

  • 🎯 Menú principal con opciones para insertar, mostrar y eliminar datos
  • 🧩 Uso de clases, listas, estructuras condicionales y bucles
  • 💾 Simulación de persistencia y control de errores
  • 📘 Guía detallada con los pasos del proyecto y sugerencias de mejora

Elige una unidad para cargar el ejercicio real del curso. Copia el código y pégalo en el compilador de abajo.

Abrir en nueva pestaña
Código del ejercicio
public class Main {
  public static void main(String[] args) {
    System.out.println(\"Elige una UT arriba 👆\");
  }
}
Consejo: en Programiz usa el nombre de clase Main si te lo pide.
Instrucciones (guía)
Selecciona una UT para cargar la guía.
Cómo practicar: 1) Copia el código 2) Pégalo en Programiz 3) Modifica y ejecuta.

Curso completo de Python · Aprende desde cero

¿Por qué aprender Python?

Rápido de aprender, útil de por vida.

Python es un lenguaje moderno y muy demandado, perfecto para empezar por su sintaxis clara. Se usa en IA, web, automatización y datos.

Aprendes rápido: menos “ruido” y más práctica desde el primer día.
Muy buscado: útil para proyectos reales y salidas laborales.
Productividad: automatiza tareas y crea herramientas propias en poco tiempo.
IA Automatización Desarrollo web Análisis de datos Scripts

Es un lenguaje interpretado: ves resultados rápido y puedes iterar sin fricción.

Herramientas necesarias

Instala esto y empieza hoy mismo.
Con esto podrás ejecutar, depurar y mejorar tu código con una experiencia profesional.

Resumen de la unidad
Objetivo + contenidos clave, en un vistazo.
Objetivo
🎯 Objetivo: entender cómo representar información en un programa y manipularla con seguridad usando variables y tipos de datos.
  • Comprender qué es una variable y nombrarla con claridad para que el código sea legible.
  • Elegir el tipo adecuado (números, texto, verdadero/falso) y convertir entre tipos sin errores.
  • Recoger datos sencillos del usuario y mostrar resultados claros y bien formateados.
  • Construir expresiones y pequeñas decisiones para resolver problemas cotidianos.
  • Organizar datos básicos con colecciones simples cuando sea conveniente.
Al terminar, podrás crear scripts cortos que reciben datos, los transforman con seguridad y muestran resultados de forma clara.
Qué aprenderás en esta unidad
  • Variables y nombres: qué son, snake_case, reasignación y buenas prácticas.
  • Tipos básicos: int, float, str, bool y conversiones (int(), float(), str(), bool()).
  • Entrada y salida: input(), errores de conversión y f-strings (f"{total:.2f}").
  • Operadores: aritméticos (+ − * / // % **), comparación (== != < > ≤ ≥), lógicos (and, or, not) y asignación compuesta (+=, -=...).
  • Colecciones mínimas: listas (crear, indexar, añadir) y diccionarios (claves/valores, actualizar).
  • Inspección/depuración: type(), len() y cómo evitar ValueError/NameError.

Resumen de la unidad
Objetivo + contenidos clave, en un vistazo.
Objetivo
🎯 Objetivo: comprender la toma de decisiones en un programa para responder a distintas situaciones de forma clara y mantenible.
  • Traducir preguntas del mundo real en condiciones lógicas (sí/no).
  • Diseñar ramificaciones simples y legibles, evitando anidaciones innecesarias.
  • Validar entradas y contemplar casos límite (vacíos, fuera de rango).
  • Escribir decisiones expresivas que muestren la intención del código.
  • Planificar el flujo: qué hacer cuando se cumple y qué si no.
Al terminar, podrás guiar el flujo de tu programa según los datos y las reglas del problema con decisiones limpias.
Qué aprenderás en esta unidad
  • Estructura condicional: if, elif, else, bloques e indentación correcta.
  • Comparaciones: ==, !=, <, > y comparación encadenada (0 <= x < 10).
  • Lógica booleana: and, or, not, precedencia y if anidados.
  • Truthy / Falsy: valores falsy (0, "", [], None) y bool().
  • Ternario: decisiones compactas en una línea ("OK" if cond else "NO").
  • match / case (3.10+): múltiples ramas legibles con comodín case _.

Resumen de la unidad
Objetivo + contenidos clave, en un vistazo.
Objetivo
🎯 Objetivo: comprender la iteración como herramienta para automatizar tareas repetitivas y procesar colecciones de datos.
  • Elegir el bucle adecuado (for para recorrer, while para condición).
  • Diseñar bucles seguros con salida bien definida evitando infinitos.
  • Aplicar patrones: contador, acumulador, búsqueda y filtrado.
  • Transformar datos en resúmenes o informes legibles.
  • Usar cortes o saltos cuando simplifiquen la lógica.
Al terminar, podrás convertir conjuntos de datos en resultados útiles sin repetir código.
Qué aprenderás en esta unidad
  • For básico: recorrer listas/strings y construir resultados paso a paso.
  • range(inicio, fin, paso): generar secuencias y hacer sumatorios/contadores.
  • enumerate(): obtener índice + valor con numeración limpia.
  • while controlado: condición clara, contador/bandera y evitar bucles infinitos.
  • Control del flujo: break, continue y else en bucles.
  • Bucles anidados: tablas de multiplicar y cuadrículas simples.
  • Comprensiones de listas: generar listas en una línea con filtro.

Resumen de la unidad
Objetivo + contenidos clave, en un vistazo.
Objetivo
🎯 Objetivo: comprender las funciones como piezas reutilizables que encapsulan una tarea para escribir programas más claros.
  • Detectar tareas repetidas y convertirlas en funciones con nombres significativos.
  • Pensar en entradas → proceso → salida (diseño de la firma).
  • Dividir problemas grandes en pasos pequeños y comprobables.
  • Reutilizar código y reducir errores al cambiar en un solo lugar.
Al terminar, podrás transformar scripts lineales en programas modulares y fáciles de probar.
Qué aprenderás en esta unidad
  • Funciones sin parámetros: bloque que ejecuta una tarea concreta y se reutiliza.
  • Parámetros posicionales: pasar datos a la función y usarlos dentro.
  • return: devolver resultados para guardarlos y reutilizarlos.
  • Valores por defecto y keyword args: llamadas claras con nombre=valor.
  • Scope básico: variables locales vs. externas; evitar global.
  • Buenas prácticas: funciones "puras", nombres con verbos y una sola responsabilidad.

Resumen de la unidad
Objetivo + contenidos clave, en un vistazo.
Objetivo
🎯 Objetivo: modelar datos reales con colecciones (listas y diccionarios) y recorrerlos para transformar, ordenar y resumir información.
  • Elegir la estructura adecuada según el problema (lista vs. diccionario).
  • Pensar en "datos → recorrido → resultado" para informes claros.
  • Planificar bucles anidados con cortes y validaciones.
  • Aplicar ordenaciones y transformaciones para conclusiones útiles.
Al terminar, convertirás colecciones en resúmenes comprensibles (inventarios, rankings).
Qué aprenderás en esta unidad
  • Listas básicas: crear, acceder, slicing y métodos útiles.
  • Diccionarios: get(), keys(), values(), items().
  • Recorrer diccionarios: iterar claves/valores para salidas legibles.
  • Estructuras anidadas: lista de dicts, dict de listas y bucles combinados.
  • Ordenación: sorted(key=...), min, max, sum.
  • Comprensiones: crear listas o dicts en una línea con filtros.
  • Integración: mini "dashboard" con totales y resumen.

Resumen de la unidad
Objetivo + contenidos clave, en un vistazo.
Objetivo
🎯 Objetivo: entender la POO como forma de modelar el mundo con clases y objetos, separando responsabilidades.
  • Pensar en estado + comportamiento: qué datos guarda y qué sabe hacer.
  • Definir interfaces sencillas y ocultar detalles con encapsulación.
  • Modelar relaciones: composición y herencia cuando aporte claridad.
  • Representar objetos de forma útil para personas y depuración.
Al terminar, convertirás requisitos en clases colaborando entre sí, listas para crecer.
Qué aprenderás en esta unidad
  • Clases y objetos: atributos, métodos y uso de self.
  • Inicialización: constructor __init__ para crear estado válido.
  • Atributos de clase vs instancia: @classmethod/@staticmethod.
  • Dunder methods: __str__, __repr__, __eq__, __len__.
  • @property: getters/setters con validación para mantener invariantes.
  • Herencia y super(): reutilizar y especializar comportamiento.
  • Composición: objetos que contienen otros objetos (tiene-un).

Resumen de la unidad
Objetivo

Construir programas robustos que no se caigan ante errores, muestren mensajes claros y cierren recursos de forma segura.

Al terminar podrás convertir scripts frágiles en programas predecibles y fáciles de mantener.
Qué aprenderás
  • try/except básico: capturar y tratar errores esperados
  • Múltiples except y jerarquía de excepciones
  • else y finally: flujos de éxito y limpieza
  • raise y validación con mensajes descriptivos
  • Excepciones personalizadas para tu dominio
  • Reintento seguro con intentos limitados

Resumen de la unidad
Objetivo

Aprender a organizar y reutilizar código mediante módulos propios y librerías externas de Python.

Al terminar sabrás importar, crear y gestionar módulos como un profesional.
Qué aprenderás
  • import y from ... import
  • Crear módulos propios y paquetes
  • Módulos estándar: os, sys, math, random
  • Instalar librerías con pip
  • Gestionar dependencias con requirements.txt

Resumen de la unidad
Objetivo

Dominar la lectura y escritura de archivos en Python: texto, CSV, JSON y binarios.

Serás capaz de persistir datos y procesar archivos de cualquier formato.
Qué aprenderás
  • open(), read(), write()
  • Context manager with para archivos
  • Modos de apertura: r, w, a, b
  • Trabajar con CSV y JSON
  • Manejo de rutas con os.path y pathlib

Resumen de la unidad
Objetivo

Crear scripts de automatización para tareas del sistema operativo y administración.

Automatizarás tareas repetitivas como un DevOps profesional.
Qué aprenderás
  • Módulo os y shutil para ficheros
  • Ejecutar comandos con subprocess
  • Variables de entorno y argumentos CLI
  • Programación de tareas y scripts batch
  • Monitorización de procesos del sistema

Resumen de la unidad
Objetivo

Conectar Python con bases de datos SQLite para almacenar y consultar información persistente.

Dominarás CRUD completo y consultas SQL desde Python.
Qué aprenderás
  • Módulo sqlite3 de Python
  • Crear tablas y ejecutar queries SQL
  • CRUD: Create, Read, Update, Delete
  • Parámetros seguros (evitar SQL Injection)
  • Transacciones y manejo de errores

Resumen de la unidad
Objetivo

Escribir tests automáticos y depurar código de forma eficiente para garantizar calidad.

Desarrollarás código más robusto con técnicas profesionales de QA.
Qué aprenderás
  • Módulo unittest y pytest
  • Escribir tests unitarios y de integración
  • Debugger pdb y breakpoints
  • Logging y trazas de errores
  • TDD: Test Driven Development básico

Resumen de la unidad
Objetivo

Dominar Flask, el microframework web más popular de Python. Desde lo básico hasta proyectos completos con estructura profesional.

Construirás aplicaciones web reales, APIs REST y aprenderás arquitectura de proyectos.
Qué aprenderás
  • Rutas, métodos HTTP y request/response
  • Templates con Jinja2 y herencia
  • Formularios, validación y CSRF
  • Sesiones, cookies y autenticación
  • APIs REST con JSON
  • Estructura de proyecto profesional (Blueprints)
Material Teórico

Tutorial completo con explicaciones paso a paso y ejemplos de código comentado.

Proyectos Prácticos Completos
Proyecto Básico

Aplicación Flask sencilla con toda la lógica en un solo archivo. Ideal para empezar.

  • app.py - Código completo
  • templates/ - 4 plantillas HTML
  • README.md - Documentación
Descargar .zip
Proyecto Avanzado

Estructura profesional con Blueprints, MVC y configuración separada.

  • app.py - Punto de entrada
  • config.py - Configuración
  • models.py - Modelos de datos
  • routes/ - Blueprints
  • templates/ - Vistas
Descargar .zip

Resumen de la unidad
Objetivo

Dominar Django, el framework web "batteries included" de Python. Aprenderás desde la configuración inicial hasta desplegar un proyecto completo.

Crearás aplicaciones web profesionales con ORM, admin, autenticación y middleware.
Qué aprenderás
  • Arquitectura MTV (Model-Template-View)
  • ORM de Django y migraciones
  • Panel de administración automático
  • Sistema de usuarios y permisos
  • URLs, vistas basadas en clases y templates
  • Middleware y configuración avanzada
Material Teórico

Tutorial completo de Django con explicaciones detalladas y ejemplos prácticos.

Proyecto Django Completo
django_pf - Proyecto Funcional

Proyecto Django completo con estructura profesional, listo para ejecutar y modificar.

  • manage.py - Script gestión
  • djpf/ - Configuración
  • settings.py
  • urls.py
  • core/ - App principal
  • views.py
  • templates/
  • middleware.py
Descargar .rar
Documentación Extra

Guías complementarias para profundizar en Django.

Práctica integradora
Objetivo

Aplicar de forma integrada todos los conocimientos aprendidos mediante una simulación realista de administración de servidores.

Combina variables, condicionales, bucles, funciones, listas y diccionarios.
Qué practicarás
  • Ver el estado de servidores con diccionarios
  • Detectar servidores sobrecargados
  • Reiniciar o apagar servidores individualmente
  • Optimizar rendimiento con lógica condicional
  • Aplicar funciones reutilizables y bucles

Selecciona una UT para ver el código Python y su guía explicativa. Puedes copiar, descargar o practicar en el editor online.

Intermedio Web
Selecciona una UT de la barra superior para cargar el código Python y su guía explicativa.
Editor Python Online

Java desde Cero · Teoría y Práctica

Accede al curso de Java organizado por temas desde variables hasta herencia, con archivos `.java` y `.md` explicativos.

Variables y Tipos de Datos

Las variables almacenan datos que usaremos en el programa. Cada una tiene un tipo.

int Enteros
double Decimales
String Texto
boolean true/false
public class Main {
  public static void main(String[] args) {
    // 1) Declaramos variables de distintos tipos
    int edad = 25;
    double altura = 1.75;
    String nombre = "Ana";
    boolean activo = true;
    final double PI = 3.1416;

    // 2) Mostramos resultados por consola
    System.out.println("Nombre: " + nombre);
    System.out.println("Edad: " + edad);
    System.out.println("Altura: " + altura);
    System.out.println("Activo: " + activo);
    System.out.println("PI: " + PI);
  }
}
Usa final para constantes que no cambian.
Editor Java
Condicionales

Ejecutan código solo si se cumple una condición.

if else if else switch
public class Main {
  public static void main(String[] args) {
    // 1) Cambia la nota y prueba
    int nota = 7;

    // 2) Decidimos mensaje segun nota
    if (nota >= 9) {
      System.out.println("Sobresaliente");
    } else if (nota >= 5) {
      System.out.println("Aprobado");
    } else {
      System.out.println("Suspenso");
    }
  }
}

Switch para múltiples opciones:

public class Main {
  public static void main(String[] args) {
    // 1) Simulamos un dia de la semana
    int dia = 2;

    // 2) Mostramos texto segun valor
    switch (dia) {
      case 1: System.out.println("Lunes"); break;
      case 2: System.out.println("Martes"); break;
      default: System.out.println("Otro dia");
    }
  }
}
Editor Java
Bucles

Repiten instrucciones múltiples veces.

for Nº conocido
while Condición
do-while Mín. 1 vez
public class Main {
  public static void main(String[] args) {
    // Recorremos del 1 al 5
    for (int i = 1; i <= 5; i++) {
      System.out.println("Numero: " + i);
    }
  }
}
public class Main {
  public static void main(String[] args) {
    // While: repetir mientras se cumpla la condicion
    int x = 0;
    while (x < 3) {
      System.out.println("Valor de x: " + x);
      x++; // evita bucle infinito
    }
  }
}
Editor Java
Funciones y Métodos

Encapsulan código para reutilizarlo. Pueden recibir parámetros y devolver valores.

modificador tipoRetorno nombre(parámetros)
public class Main {
  // Metodo que devuelve un valor
  public static int sumar(int a, int b) {
    return a + b;
  }

  // Metodo que no devuelve valor
  public static void saludar(String nombre) {
    System.out.println("Hola " + nombre);
  }

  public static void main(String[] args) {
    int resultado = sumar(5, 3);
    System.out.println("Suma: " + resultado);
    saludar("Maria");
  }
}
return devuelve valor void sin retorno
Editor Java
Arrays

Almacenan múltiples valores del mismo tipo.

Los índices empiezan en 0
public class Main {
  public static void main(String[] args) {
    // 1) Declaramos un array
    int[] numeros = {10, 20, 30, 40};

    // 2) Accedemos a posiciones y tamano
    System.out.println(numeros[0]);
    System.out.println(numeros.length);

    // 3) Recorremos todo el array
    for (int n : numeros) {
      System.out.println(n);
    }
  }
}
[0] primer elemento .length tamaño
Editor Java
Programación Orientada a Objetos

Organiza el código en clases con atributos y métodos.

Clase Plantilla
Objeto Instancia
class Persona {
  String nombre;
  int edad;

  void saludar() {
    System.out.println("Hola, soy " + nombre);
  }
}

public class Main {
  public static void main(String[] args) {
    // Creamos un objeto a partir de la clase Persona
    Persona p = new Persona();
    p.nombre = "Maria";
    p.edad = 25;
    p.saludar();
  }
}
Editor Java
Herencia y Polimorfismo

Una clase puede heredar de otra con extends.

Herencia: La clase hija recibe atributos y métodos del padre.
class Animal {
  void hacerSonido() {
    System.out.println("Sonido generico");
  }
}

class Perro extends Animal {
  @Override
  void hacerSonido() {
    System.out.println("Guau guau");
  }
}

public class Main {
  public static void main(String[] args) {
    // Polimorfismo: referencia de tipo padre
    Animal miAnimal = new Perro();
    miAnimal.hacerSonido();
  }
}
Editor Java
Excepciones

Permiten manejar errores sin detener el programa.

try Intenta
catch Captura
finally Siempre
public class Main {
  public static void main(String[] args) {
    try {
      // Forzamos un error para aprender a capturarlo
      int resultado = 10 / 0;
      System.out.println(resultado);
    } catch (ArithmeticException e) {
      System.out.println("Error: " + e.getMessage());
    } finally {
      // Este bloque siempre se ejecuta
      System.out.println("Fin del bloque");
    }
  }
}
Editor Java
Mini ejercicio guiado (sin resolver)

Objetivo: entender la idea y escribir tu propia solucion en el editor.

  • Lee el objetivo del bloque.
  • Copia, pega y completa el TODO.
  • Ejecuta y mejora una parte por tu cuenta.
public class Main {
  public static void main(String[] args) {
    // Escribe aqui tu ejercicio
  }
}

A continuación tienes las prácticas organizadas por bloques de contenido clave del curso. Cada bloque incluye:

  • 📄 Un archivo .java con la práctica base con comentarios para rellenar.
  • 📘 Un archivo .md con soluciones explicadas y teoría de refuerzo.

Temas: UT1 (Variables, tipos, operadores) + UT2 (Condicionales)

  • 📌 Mostrar datos por pantalla
  • 📌 Uso de constantes y entrada por teclado
  • 📌 Estructuras if, else y switch

Temas: UT3 (for, while, do-while) + UT4 (funciones)

  • 📌 Bucles contadores, sumatorios y menús
  • 📌 Paso de parámetros y modularización

Temas: UT5 (Arrays) + UT6 (ArrayList, HashMap)

  • 📌 Notas de alumnos, temperaturas, tablas
  • 📌 Listas dinámicas y mapas clave-valor

Temas: UT7 (POO) + UT8 (Herencia y polimorfismo)

  • 📌 Creación de clases, objetos y métodos
  • 📌 Herencia, interfaces y sobreescritura

Temas: UT9 (Excepciones), UT10 (Fechas y Math), UT11–12 (Ficheros)

  • 📌 Control de errores, validaciones
  • 📌 Uso de fechas, cálculos y lectura/escritura de archivos

Cómo funciona esta sección

En cada bloque verás:

  • 🧠 Resumen teórico muy claro y visual
  • 💻 Ejercicio práctico para completar o probar online
  • 🧪 Test autocalificable con 5 preguntas y puntuación final

Perfecto para repasar antes de exámenes o resolver dudas por bloques temáticos.

¿Qué es una variable en Java?

Una variable es un espacio de memoria que usamos para almacenar datos. En Java, cada variable debe declararse indicando su tipo.

// Declaración de una variable entera
int edad = 25; // Guarda un número entero

// Declaración de un número decimal
double altura = 1.75; // Guarda un número con decimales

// Declaración de texto
String nombre = "Joaquín"; // Guarda una cadena de caracteres

// Declaración de valor verdadero/falso
boolean esMayor = true; // Guarda true o false

💡 En Java, los nombres de variables empiezan con minúscula, y no pueden llevar espacios.

Ejercicio guiado

Crea un programa que declare tres variables:

  • String nombre → Guarda tu nombre
  • int edad → Guarda tu edad
  • boolean esMayor → Calcula si tu edad es mayor o igual a 18

El programa debe imprimir esta frase:

Me llamo Joaquín, tengo 30 años y ¿soy mayor de edad? true
Ejemplo de cómo podría quedar tu programa:
public class DatosPersona {
  public static void main(String[] args) {
    String nombre = "Laura";
    int edad = 22;
    boolean esMayor = edad >= 18;

    System.out.println("Me llamo " + nombre +
                       ", tengo " + edad +
                       " años y ¿soy mayor de edad? " + esMayor);
  }
}
Test interactivo: Variables

1. ¿Cuál es el tipo correcto para almacenar un número decimal?

double
int
boolean
String

2. ¿Qué imprime el siguiente código?
int x = 5; System.out.println(x + 3);

8
x + 3
53
Error

3. ¿Qué palabra define un texto?

String
Text
TextField
Char

4. ¿Qué resultado tiene este código?
boolean activo = true; System.out.println(activo);

true
activo
1
Error

5. ¿Qué símbolo se usa para definir una cadena?

"dobles comillas"
'comillas simples'
<>
//

6. ¿Qué valor muestra este código?
int edad = 18; System.out.println(edad >= 18);

true
false
edad
Error

7. ¿Cómo se declara correctamente un char?

char letra = 'A';
char letra = "A";
character letra = A;
string letra = 'A';

8. ¿Qué imprime este código?
String saludo = "Hola"; System.out.println(saludo);

Hola
saludo
"Hola"
Error

9. ¿Qué tipo se usa para un valor verdadero/falso?

boolean
String
int
char

10. ¿Qué muestra este código?
final double PI = 3.14; System.out.println(PI);

3.14
PI
final
Error

¿Qué es una estructura condicional?

En Java, una estructura condicional te permite ejecutar diferentes líneas de código en función de que una expresión booleana sea true o false. Son la base para tomar decisiones y controlar el flujo de tu programa.

1. if / else

La forma más sencilla: comprueba una única condición.

// Declaramos una variable
int edad = 17;

// if: si la condición (edad >= 18) es true, entra en el primer bloque.
// else: si es false, ejecuta el bloque alternativo.
if (edad >= 18) {
  System.out.println("Puedes votar.");      // no se ejecuta: 17 < 18
} else {
  System.out.println("Aún no puedes votar."); // se muestra por consola
}
  • if (condición): lleva paréntesis y llaves obligatorias.
  • else: va justo después de cerrar el if.
2. else if

Cuando quieres comprobar varias condiciones en secuencia:

int nota = 7;

if (nota < 5) {
  System.out.println("Suspenso");
} else if (nota < 7) {
  System.out.println("Aprobado");
} else if (nota < 9) {
  System.out.println("Notable");
} else {
  System.out.println("Sobresaliente");
}
  • Se evalúa de arriba abajo y se ejecuta sólo el primer bloque cuya condición es true.
3. switch / case

Útil cuando tienes muchas opciones basadas en el mismo valor (por ejemplo, días de la semana):

int dia = 3;

switch (dia) {
  case 1:
    System.out.println("Lunes");
    break;           // sin break continúa al siguiente case
  case 2:
    System.out.println("Martes");
    break;
  case 3:
    System.out.println("Miércoles");
    break;
  default:
    System.out.println("Otro día");
}
  • case X: compara dia == X.
  • break; detiene el switch tras ejecutar ese bloque.
  • default: bloque por defecto si ningún case coincide.
4. Operadores lógicos y de comparación
  • ==, !=, <, >, <=, >= → comparadores básicos
  • && (AND): todas deben ser true
  • || (OR): basta con una true
  • ! (NOT): invierte el valor booleano
Ejercicio guiado

Vamos a crear un programa que pida por consola una nota (número entero entre 0 y 10) y, según ese valor, muestre por pantalla el siguiente mensaje:

  • 0–4: Suspenso
  • 5–6: Aprobado
  • 7–8: Notable
  • 9–10: Sobresaliente

Sigue estos pasos en tu IDE o editor preferido:

  1. Lee la nota con Scanner.
  2. Guarda la entrada en una variable int nota.
  3. Usa if / else if / else o switch para clasificar la nota.
  4. Imprime el resultado con System.out.println.
Plantilla de partida:
import java.util.Scanner;

public class EvaluarNota {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.print("Introduce tu nota (0–10): ");
    int nota = sc.nextInt();

    // Aquí irá tu lógica condicional

    sc.close();
  }
}
Ejemplo resuelto con if/else if:
if (nota < 5) {
  System.out.println("Suspenso");
} else if (nota < 7) {
  System.out.println("Aprobado");
} else if (nota < 9) {
  System.out.println("Notable");
} else {
  System.out.println("Sobresaliente");
}
Test interactivo: Condicionales
  1. ¿Qué imprime este código?
    int x = 4;
    if (x > 5) System.out.print("A");
    else System.out.print("B");
    A
    B
    Error
    Nada

  2. ¿Cuál es el operador lógico "o" en Java?
    &&
    ||
    !
    ==

  3. ¿Qué muestra este código si nota = 10?
    if (nota >= 9) System.out.println("Excelente");
    Aprobado
    Excelente
    Suspendido
    Error

  4. ¿Cuál es la sintaxis correcta?
    if condicion then
    if (condicion) { }
    si entonces
    condicional

  5. ¿Qué valor tiene esta condición?
    3 > 5
    true
    false
    null
    undefined
  1. ¿Qué se usa cuando falla la condición?
    else
    switch
    break
    case

  2. ¿Qué imprime este código?
    int nota = 6;
    if (nota >= 5) System.out.println("Correcto");
    Correcto
    Error
    Nada
    Fallo

  3. ¿Qué estructura se usa para múltiples opciones?
    if
    switch
    else
    case

  4. ¿Qué muestra este código?
    int dia = 5;
    switch(dia) {
      case 1: System.out.print("Lunes"); break;
      default: System.out.print("Otro");
    }
    Lunes
    Otro
    Viernes
    Martes

  5. ¿Qué operador representa la negación lógica?
    !
    not
    -
    ~

¿Qué son y para qué sirven los bucles?

Un bucle te permite ejecutar repetidamente un bloque de código mientras se cumpla una condición. Son ideales para automatizar tareas repetitivas, procesar colecciones o iterar sobre rangos de valores.

1. Bucle for

Definido por tres partes: inicialización, condición y actualización.

// Recorre i desde 0 hasta 4 (total 5 iteraciones)
for (int i = 0; i < 5; i++) {
  System.out.println("Iteración número " + i);
  // i++ incrementa i en cada vuelta
}
2. Bucle while

Primero comprueba la condición y si es true, ejecuta el cuerpo.

int contador = 0;
// Mientras contador sea menor que 5, se repite
while (contador < 5) {
  System.out.println("Valor actual: " + contador);
  contador++;  // sin esto, quedaría en bucle infinito
}
3. Bucle do…while

Garantiza al menos una ejecución antes de evaluar la condición.

int n = 0;
do {
  System.out.println("Primera impresión: " + n);
  n++;
} while (n < 5); // comprueba tras ejecutar el bloque
4. Palabras clave de control
  • break → sale inmediatamente del bucle.
  • continue → salta al siguiente ciclo, omitiendo el resto del cuerpo.
Ejercicio guiado

Vamos a escribir un programa que imprima por pantalla los números del 1 al 10 usando for.

Paso a paso:
  1. Crea una clase Java con public static void main.
  2. Usa un bucle for donde:
    • int i = 1 (inicio)
    • i <= 10 (condición)
    • i++ (actualización)
  3. Dentro del bucle, System.out.println(i);
Plantilla de partida:
public class CuentaRegresiva {
  public static void main(String[] args) {
    // Empezamos en 1, queremos llegar hasta 10
    for (int i = 1; i <= 10; i++) {
      System.out.println(i);
    }
  }
}
Test interactivo: Bucles
  1. ¿Cuántas iteraciones hace este for?
    for (int i = 0; i < 3; i++) {
      System.out.print(i);
    }
    3
    2
    1
    4

  2. ¿Qué bucle garantiza al menos una ejecución?
    for
    while
    do while
    if

  3. ¿Qué imprime este while?
    int i = 1;
    while (i < 4) {
      System.out.print(i);
      i++;
    }
    123
    012
    124
    345

  4. ¿Cómo sales de un bucle antes de tiempo?
    break
    return
    exit
    stop

  5. ¿Qué valor imprime este código?
    int suma = 0;
    for (int i = 1; i <= 3; i++) {
      suma += i;
    }
    System.out.print(suma);
    6
    3
    10
    5
  1. ¿Para qué sirve continue?
    Omitir resto de la vuelta
    Salir del bucle
    Reiniciar bucle
    No hace nada

  2. ¿Cuál es la salida de este do…while?
    int x = 0;
    do {
      x++;
    } while (x < 3);
    System.out.print(x);
    3
    4
    2
    1

  3. ¿Qué imprime este bucle?
    for (int i = 5; i > 0; i--) {
      System.out.print(i);
    }
    54321
    12345
    55555
    Error

  4. ¿Cuántas vueltas hace este for?
    for (int i = 2; i <= 8; i += 2) {
      // ...
    }
    4
    8
    3
    5

  5. ¿Qué condición hace un bucle infinito?
    while (true) {
      // ...
    }
    true
    false
    i<5< /div>
    i>5

¿Qué es un método?

Un método (o función en otros lenguajes) es un bloque de código al que le das un nombre, le pasas parámetros y te devuelve un resultado. En Java, todo método debe formar parte de una clase.

1. Sintaxis básica:
public class Utilidades {
  // public: accesible desde cualquier clase
  // static: no necesitas crear instancia de Utilidades para usarlo
  // int: tipo de dato que devuelve este método
  // sumar: nombre del método
  // (int a, int b): parámetros de entrada, dos enteros
  public static int sumar(int a, int b) {
    // cuerpo: devuelve la suma de a y b
    return a + b;
  }
}
2. Llamar a un método:
public class App {
  public static void main(String[] args) {
    // Invocamos Utilidades.sumar y guardamos el resultado
    int resultado = Utilidades.sumar(3, 5);
    System.out.println("3 + 5 = " + resultado);  // imprime: 3 + 5 = 8
  }
}
3. Métodos void (sin retorno):
public class Mensajes {
  // void: no devuelve nada
  public static void saludar(String nombre) {
    System.out.println("¡Hola, " + nombre + "!");
  }
}
4. Parámetros vs. argumentos:
  • Parámetros son las variables que defines en la firma del método (String nombre).
  • Argumentos son los valores que pasas al llamar (saludar("Ana")).
Ejercicio guiado

Crea un método que reciba una edad y devuelva true si puede votar (>=18) o false si no.

Pauta:

  1. Define una clase Votacion.
  2. Dentro, crea public static boolean puedeVotar(int edad).
  3. Usa return edad >= 18;.
  4. En el main, llama a puedeVotar con distintas edades y muéstralo.
Test interactivo: Funciones y Métodos
  1. ¿Qué palabra clave devuelve un valor?
    return
    exit
    send
    output

  2. En public static boolean esPar(int n), ¿qué devuelve?
    int
    boolean
    void
    String

  3. ¿Cómo se llama este método?
    public static void saludar()
    saludar()
    main()
    void.saludar
    run.saludar

  4. ¿Qué imprime?
    System.out.println(sumar(2, 3));
    23
    5
    2+3
    Error

  5. ¿Qué significa void?
    No devuelve valor
    Devuelve texto
    Devuelve booleano
    Devuelve número
  1. ¿Qué es un parámetro?
    Variable local
    Valor que recibe el método
    Una clase
    Un bucle

  2. Firma correcta de main:
    public static void main(String[] args)
    public void main(String[] args)
    static main(String args)
    main() void

  3. ¿Cuántos valores devuelve un método?
    Solo uno
    Varios
    Ninguno
    Depende

  4. ¿Qué ocurre si un método void usa return valor?
    Error de compilación
    Devuelve null
    Se ignora
    Se ejecuta igual

  5. ¿Cómo llamas a un método sin parámetros?
    metodo()
    metodo
    call metodo
    invoke metodo()

¿Qué es una clase y un objeto?

Java es un lenguaje orientado a objetos. Esto significa:

  • Clase: Plantilla o plano que define atributos (datos) y métodos (comportamientos).
  • Objeto: Instancia concreta de una clase, con sus propios valores para esos atributos.
1. Definición de clase:
// Definimos el plano de Persona
public class Persona {
  // Atributos (propiedades)
  String nombre;      // almacena el nombre
  int edad;           // almacena la edad

  // Método que imprime un saludo
  void saludar() {
    System.out.println("Hola, soy " + nombre + " y tengo " + edad + " años.");
  }

  // Método que indica si es mayor de edad
  boolean esMayorDeEdad() {
    return edad >= 18;  // devuelve true si edad ≥ 18
  }
}
2. Crear y usar un objeto:
// Clase con método main
public class Principal {
  public static void main(String[] args) {
    // 1. Instanciamos un objeto de tipo Persona
    Persona p1 = new Persona();
    // 2. Asignamos valores a sus atributos
    p1.nombre = "Laura";
    p1.edad   = 22;
    // 3. Llamamos a sus métodos
    p1.saludar();                         // imprime saludo
    System.out.println("Mayor de edad? " + p1.esMayorDeEdad());
  }
}

💡 Resumen: Una clase agrupa datos y comportamientos. Cada objeto es un ejemplar con valores propios.

Ejercicio práctico

Crea una clase Coche con:

  • 🟢 Atributos: marca (String), modelo (String), anio (int).
  • 🔧 Método mostrarInformacion(): imprime todos los datos.
  • ✅ Método esAntiguo(): devuelve true si anio < 2010.

Después, en Main, instancia un Coche, asígnale valores, y llama ambos métodos.

Test interactivo: Clases y Objetos
  1. ¿Qué es una clase?
    Plano o plantilla
    Objeto real
    Función
    Variable

  2. ¿Qué hace new Persona()?
    Crea un objeto
    Declara variable
    Llama método
    Nada

  3. Palabra clave para definir una clase:
    class
    object
    public
    void

  4. ¿Qué es un método?
    Acción o comportamiento
    Dato
    Variable
    Clase

  5. ¿Qué imprime saludar() en el ejemplo?
    Hola, soy Laura y tengo 22 años.
    Error
    Nada
    Adiós
  1. ¿Qué devuelve esMayorDeEdad() si edad=16?
    false
    true
    Error
    16

  2. ¿Cómo accedes a un método de un objeto?
    p1.saludar()
    p1->saludar()
    saludar()
    Principal.saludar()

  3. Un atributo describe:
    Un dato
    Una acción
    Una clase
    Un método

  4. ¿Qué imprime System.out.println(edad >= 18); si edad=20?
    true
    false
    20
    Error

  5. ¿Qué hace esAntiguo() en Coche?
    Comprueba si es anterior a 2010
    Imprime datos
    Nada
    Suma años

¿Qué es un array?

Un array es una estructura de datos que permite almacenar múltiples valores del mismo tipo en una sola variable. Se accede a los elementos por su índice, que empieza en 0.

🔹 Declaración e inicialización:
// Declarar un array de 5 enteros
int[] numeros = new int[5];

// Inicializar posiciones
numeros[0] = 10;
numeros[1] = 20;

// Declarar e inicializar en una línea
String[] nombres = {"Ana", "Luis", "María"};

// Mostrar un valor
System.out.println(nombres[1]); // Imprime: Luis
🔹 Recorrer un array con bucles:
for (int i = 0; i < nombres.length; i++) {
  System.out.println("Nombre: " + nombres[i]);
}
  • 📌 array.length da el número total de elementos
  • 📌 Los índices van de 0 a length - 1
  • 📌 Si accedes fuera del rango, da error (ArrayIndexOutOfBoundsException)
Ejercicio guiado

Crea un programa que almacene las temperaturas de 7 días, las muestre y calcule la media semanal. Por ejemplo:

public class Temperaturas {
  public static void main(String[] args) {
    double[] temps = {21.5, 19.0, 22.3, 20.0, 18.7, 23.1, 20.5};
    double suma = 0;
    for (double t : temps) {
      System.out.println("Temp día: " + t + "°C");
      suma += t;
    }
    double media = suma / temps.length;
    System.out.println("Media semanal: " + media + "°C");
  }
}
Test interactivo: Arrays

1. ¿Cuál es el índice inicial en un array en Java?

0
1

2. ¿Qué ocurre si accedes a un índice fuera del rango?

Lanza excepción
No ocurre nada

3. ¿Cuál es el valor de numeros[2] en int[] numeros = {1, 2, 3, 4};?

3
2

4. ¿Qué declaración es válida?

int[] nums = new int[5];
array = int();

5. ¿Qué se imprime?

String[] colores = {"Rojo", "Verde"};
System.out.println(colores[1]);

Verde
Rojo

6. ¿Cómo recorremos todo un array?

Con un bucle for del 0 al length - 1
Solo se accede al primero

7. ¿Qué tipo de datos puede almacenar un array?

Todos del mismo tipo
Mezcla de tipos

8. ¿Cuántos elementos tiene el array int[] datos = new int[4];?

4
5

9. ¿Qué opción crea un array de Strings con 3 espacios?

String[] nombres = new String[3];
String nombre = {};

10. ¿Qué resultado da esta suma?

int[] numeros = {5, 5, 5};
System.out.println(numeros[0] + numeros[1] + numeros[2]);

15
10

¿Qué son las colecciones en Java?

Las colecciones facilitan trabajar con grupos de objetos de forma dinámica, sin tener que gestionar manualmente su tamaño. Se agrupan en tres tipos básicos:

  • List: mantiene orden y permite duplicados. Ejemplo: ArrayList.
  • Set: no permite duplicados; no garantiza orden (ej. HashSet) o bien lo mantiene ordenado (ej. TreeSet).
  • Map: almacena pares clave-valor; cada clave es única (ej. HashMap, TreeMap).
Ejemplo completo y comentado:
// Importamos colecciones
import java.util.*;

public class DemoColecciones {
  public static void main(String[] args) {
    // 1. Creamos una lista de frutas (permite duplicados y orden)
    List frutas = new ArrayList<>();
    frutas.add("Manzana");    // índice 0
    frutas.add("Banana");     // índice 1
    frutas.add("Manzana");    // duplicado

    // 2. Convertimos a Set para eliminar duplicados
    Set conjuntoFrutas = new HashSet<>(frutas);

    // 3. Creamos un Map que asocia cada fruta con su longitud
    Map mapaLongitud = new HashMap<>();
    for (String f : conjuntoFrutas) {
      mapaLongitud.put(f, f.length());
    }

    // 4. Mostramos resultados
    System.out.println("Lista original: " + frutas);
    System.out.println("Conjunto sin duplicados: " + conjuntoFrutas);
    System.out.println("Mapa (fruta → longitud): " + mapaLongitud);
  }
}

💡 Clave: usar el constructor de cada colección para convertir entre ellas y aprovechar sus características.

Ejercicio guiado

Escribe un programa que:

  1. Cree un List con números: [5, 3, 8, 3, 5].
  2. Use un Set para eliminar duplicados.
  3. Ordene los números únicos de menor a mayor (convierte a TreeSet).
  4. Convierta ese TreeSet en List y muéstrelo.
Test interactivo: Colecciones

1. ¿Qué clase mantiene orden de inserción y permite duplicados?

ArrayList
HashSet
TreeSet
HashMap

2. ¿Cuál no admite elementos repetidos?

HashSet
ArrayList
LinkedList
Vector

3. ¿Qué interfaz define mapas clave-valor?

Map
Set
List
Queue

4. ¿Cómo añades al final de un List?

add()
put()
offer()
push()

5. ¿Qué método elimina todas las entradas de un Map?

clear()
removeAll()
delete()
empty()

6. ¿Qué devuelve map.get("X") si no existe clave?

null
0
Exception
false

7. ¿Qué clase ordena elementos automáticamente?

TreeSet
HashSet
ArrayList
LinkedHashSet

8. ¿Qué colección permite acceder por índice?

List
Set
Map
Queue

9. ¿Qué método comprueba si un Set está vacío?

isEmpty()
empty()
size()
clear()

10. ¿Cómo obtienes todas las claves de un Map?

keySet()
values()
entrySet()
getKeys()

¿Qué son las excepciones?

En Java, una excepción es un evento que interrumpe el flujo normal del programa cuando ocurre un error en tiempo de ejecución. Existen dos grandes tipos:

  • Checked: deben declararse o manejarse obligatoriamente (IOException, ClassNotFoundException).
  • Unchecked: heredan de RuntimeException y no es obligatorio atraparlas (NullPointerException, ArithmeticException).

Para gestionar excepciones usamos: try → bloque donde puede ocurrir el error, catch → atrapa y maneja la excepción, finally → se ejecuta siempre, haya o no excepción.

🔹 Ejemplo completo:
// Intentamos dividir por cero
try {
  int resultado = 10 / 0;              // lanza ArithmeticException
  System.out.println(resultado);
} catch (ArithmeticException ex) {
  // este bloque captura y maneja la excepción
  System.out.println("¡Cuidado! División por cero: " + ex.getMessage());
} finally {
  // se ejecuta siempre
  System.out.println("Fin del bloque try/catch");
}

En este ejemplo:
• Si la división falla, entramos en catch
finally corre siempre, ideal para cerrar recursos (ficheros, conexiones…)

Ejercicio guiado

Crea un programa que:

  1. Pida al usuario dos números enteros (a y b).
  2. Intente dividir a entre b.
  3. Si b es cero, capture la excepción y muestre: "No puedo dividir por cero, prueba con otro divisor."
  4. En finally, imprima: "Operación finalizada."

Ejemplo de código:

import java.util.Scanner;

public class DemoExcepciones {
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.print("Introduce dividendo: ");
    int a = sc.nextInt();
    System.out.print("Introduce divisor: ");
    int b = sc.nextInt();

    try {
      int resultado = a / b;                              // posible error
      System.out.println("Resultado: " + resultado);
    } catch (ArithmeticException e) {
      System.out.println("No puedo dividir por cero, prueba con otro divisor.");
    } finally {
      System.out.println("Operación finalizada.");
      sc.close();
    }
  }
}
Test interactivo: Excepciones
  1. ¿Con qué palabra reservada se inicia el bloque que puede fallar?
    try
    catch
    throw
    finally

  2. ¿Cuál se ejecuta siempre, haya excepción o no?
    finally
    catch
    try
    throw

  3. ¿Qué excepción lanza dividir por cero?
    ArithmeticException
    NullPointerException
    IOException
    IndexOutOfBoundsException

  4. ¿Cómo capturas una excepción?
    catch
    try
    finally
    throw

  5. Si no manejas una checked exception, ¿qué sucede?
    Error de compilación
    NullPointerException
    Se ignora
    RuntimeException
  1. ¿Qué palabra clave lanza una excepción manualmente?
    throw
    throws
    catch
    try

  2. ¿Para qué sirve throws en la firma de un método?
    Declarar posibles excepciones
    Capturar excepciones
    Finalizar el método
    Lanzar NullPointer

  3. ¿Qué excepción sale al usar un objeto nulo?
    NullPointerException
    ArithmeticException
    IOException
    FileNotFoundException

  4. ¿Dónde cierras recursos como Scanner?
    finally
    catch
    try
    throw

  5. ¿Qué imprime si todo va bien y no hay división por cero?
    Resultado: X
    Error
    Operación finalizada.
    NullPointerException

¿Por qué este proyecto es tan importante?

Este es tu primer proyecto Java completo, listo para presentar, practicar, y subir a GitHub. Aquí verás cómo se integran todas las piezas del curso en una sola aplicación funcional.

Con esta aplicación de consola, dominarás:

  • ✔️ Creación de objetos y clases
  • ✔️ Bucles y estructuras condicionales
  • ✔️ Gestión de listas (ArrayList)
  • ✔️ Guardado y carga de datos desde ficheros
  • ✔️ Programación modular y limpia

🎓 Es el ejercicio perfecto para repasar y demostrar lo aprendido en el curso.

Contenido del proyecto
  • GestorAlumnos.java: código completo con menú, lógica, clases y TODOs marcados para ampliar
  • GestorAlumnos.md: una guía teórica con explicaciones, conceptos reforzados y pasos para cada función

Este proyecto está diseñado para practicar, modificar, añadir código propio y dominar Java básico-intermedio.

¿Qué aprenderás con este ejercicio?
  • 🧱 POO: clases, herencia, polimorfismo, constructores
  • 🔄 Bucles y condiciones aplicadas a casos reales
  • 🧮 Colecciones (ArrayList) y operaciones sobre ellas
  • 📁 Guardar y cargar datos con ficheros (I/O)
  • 📊 Mostrar estadísticas, filtrar, buscar, eliminar...
  • 🧠 Cómo estructurar una aplicación en consola reutilizable

Además, reforzarás los comentarios profesionales con el estilo // Better Comments y dejarás preparada tu app para ampliarla (por ejemplo, con base de datos en el futuro).

¿Cómo se ejecuta el proyecto en tu entorno?

  1. Abre la carpeta que contiene GestorAlumnos.java
  2. Instala la extensión Java Extension Pack
  3. Haz clic derecho sobre el archivo y selecciona Run Java
  4. Verás el menú interactivo en la consola inferior

  1. Abre el proyecto o importa la carpeta donde está el código
  2. Haz clic en GestorAlumnos.java
  3. Pulsa el botón verde ▶️ o botón derecho > Run
  4. Se abrirá la consola con el menú interactivo

  1. Crea un proyecto nuevo tipo "Java con Ant"
  2. Pega el archivo GestorAlumnos.java en la carpeta src
  3. Clic derecho > Run File

🧠 Este proyecto está preparado para ampliarse, practicar cada punto del temario y presentarlo como ejercicio final de curso.

Teoría de Git · Guía completa

¿Qué es Git?

Git es un programa que sirve para guardar la historia de tu proyecto. Piensa en él como una “máquina del tiempo del código”: cada vez que avanzas, puedes sacar una foto de tu trabajo (commit) y volver atrás si algo sale mal.

📦 Repositorio
Carpeta de tu proyecto + una subcarpeta oculta .git con el historial.
📸 Commit
Una foto de tus cambios con un mensaje que los describe.
🌿 Rama
Una línea de trabajo paralela donde pruebas cosas sin romper la principal (main).
¿Para qué sirve?
  • Seguridad: puedes volver a versiones anteriores cuando algo falla.
  • Orden: trabajas en diferentes ramas sin mezclar cambios.
  • Trabajo en equipo: varias personas pueden colaborar sin pisarse el código.
  • Historial: sabes quién hizo qué y cuándo.
👉 Git ≠ GitHub: Git es la herramienta que corre en tu ordenador. GitHub (o GitLab / Bitbucket) son páginas donde guardas tu proyecto en la nube para compartirlo y colaborar con otros.
¿Dónde descargarlo?

Descarga oficial en: git-scm.com/downloads

Tras instalarlo, tendrás disponible el comando git en tu terminal (PowerShell en Windows, Terminal en macOS/Linux).

Movimientos clave
  • add: Working → Staging (git add .)
  • commit: Staging → Repo local (git commit -m)
  • push: Local → Remote (git push)
  • pull: Remote → Local (git pull --ff-only)
  • fetch: Remote → refs (git fetch)
Conceptos clave
  • Branch: línea de trabajo (main, feature/x)
  • HEAD: tu “puntero” actual
  • Upstream: la rama remota asociada (git push -u)
Checklist · ¿Listo para instalar?
  1. Entiendo las 4 cajas: Working, Staging, Local, Remote.
  2. Sé los pasos básicos: add → commit → push / pull.
  3. Trabajaré en main y usaré ramas para features.

Idea: tras instalar Git, define tu identidad y un editor para los mensajes de commit/merge.

# Ver versión instalada
git --version

# Configurar identidad global
git config --global user.name "Tu Nombre"
git config --global user.email "tucorreo@ejemplo.com"

# Editor recomendado (VS Code)
git config --global core.editor "code --wait"

# Rama principal por defecto
git config --global init.defaultBranch main
Mini-lab: abre una terminal y pega todo el bloque anterior. Comprueba con git config --global --list.

Idea: git init crea un repo vacío; git clone copia uno existente.

# 1) Crear repo nuevo en una carpeta
mkdir git-ejercicio && cd git-ejercicio
git init
echo "Hola Git" > README.md
git add README.md
git commit -m "feat: primer commit"

# 2) Clonar un repo existente (ejemplo)
cd ..
git clone https://github.com/usuario/proyecto.git
cd proyecto
Mini-lab: ejecuta el bloque. Verás una carpeta git-ejercicio con tu primer commit y (si clonas) otra carpeta con el repo remoto.

Idea: Working Directory → Staging Area → Repository (commit).

# Ver estado actual
git status

# Añadir un archivo concreto
git add archivo.txt

# Añadir todo lo modificado
git add .

# Crear un commit
git commit -m "feat: mensaje descriptivo y corto"

# Ver historial (formato útil)
git log --oneline --graph --decorate --all
Mini-lab: modifica README.md, confirma un par de commits y visualiza el árbol con git log --oneline --graph.

Idea: desarrolla una feature en su propia rama y luego intégrala en main.

# Listar ramas
git branch

# Crear y cambiar a una rama (comando moderno)
git switch -c feature/nueva-funcionalidad

# ...haz commits aquí...

# Volver a main
git switch main

# Fusionar la rama en main
git merge feature/nueva-funcionalidad

# Eliminar la rama ya fusionada
git branch -d feature/nueva-funcionalidad
Mini-lab: crea la rama feature/saludo, edita README.md, confirma, vuelve a main y haz merge.

Idea: vincula un remoto (origin), sube tus commits y trae cambios con seguridad.

# Enlazar remoto llamado "origin" (ejemplo SSH recomendado)
git remote add origin git@github.com:usuario/proyecto.git

# Subir commits a main y establecer upstream (solo la 1ª vez)
git push -u origin main

# Actualizar tu main desde el remoto sin crear merges accidentales
git pull --ff-only

# Descargar referencias sin fusionar (útil antes de rebase)
git fetch
¿Qué es upstream? Es la rama remota a la que tu rama local “apunta” por defecto. Tras git push -u origin main, ya puedes usar simplemente git push/git pull.

Idea: descarta cambios, revierte commits y usa el “salvavidas” reflog.

# Descartar cambios en un archivo (working directory)
git restore ruta/archivo

# Quitar del área de preparado (staging)
git restore --staged ruta/archivo

# Volver todo al último commit (⚠️ pierdes cambios sin confirmar)
git reset --hard HEAD

# Crear un commit que "deshace" otro ya publicado
git revert <hash-commit>

# Recuperación total si te equivocas (historial de movimientos)
git reflog
# ...elige un hash anterior y vuelve allí:
git reset --hard <hash-bueno>
⚠️ Cuidado: reset --hard borra cambios no confirmados. Usa antes git reflog si dudas.

Idea: inspecciona qué cambió, cuándo y por quién; compara commits.

# Diferencias en tu working directory
git diff

# Registro compacto y gráfico de todas las ramas
git log --oneline --graph --decorate --all

# Ver diferencias entre dos commits
git diff <commit1> <commit2>

# Alias útil (opcional) para ver historia bonita
git config --global alias.lg "log --oneline --graph --decorate --all"
# Luego usa: git lg
Mini-lab: crea dos commits y usa git diff <hash1> <hash2> para ver qué cambió entre ellos.

🧪 Práctica Git: Dominando el control de versiones

¿Qué vas a aprender?

Esta sección está diseñada para que practiques con un repositorio real desde GitHub y desarrolles tus habilidades en Git. Realizarás acciones fundamentales como clonar, crear ramas, fusionar, hacer commits, y sincronizar cambios, tanto por terminal como desde un IDE profesional.

Se incluyen dos prácticas:

  • Práctica 1: Uso completo de un repositorio público de GitHub (Hello World).
  • Práctica 2: Tu guía de examen personalizada con comandos paso a paso para simular un entorno de evaluación.

Repositorio base: https://github.com/octocat/Hello-World

🔰 Antes de empezar: Un Fork es una copia completa del repositorio en tu cuenta de GitHub. Lo usas cuando no tienes permisos para modificar el original, pero quieres practicar y subir tus propios cambios. 👉 Si solo quieres probar en tu ordenador, basta con clonar el repositorio original. 👉 Si además quieres subir cambios a GitHub, crea primero un Fork en tu cuenta y clona ese en lugar del original.

Qué vas a hacer

Traer a tu equipo una copia completa del proyecto (código e historial). Si vas a practicar libremente, clona tu fork para poder subir cambios.

  • Necesitas la URL HTTPS del repo (o SSH si tienes clave configurada).
  • Comprueba el remoto: git remote -v (debería verse origin).
  • Ruta de trabajo: entra a la carpeta del proyecto tras clonar.
git clone https://github.com/TUUSUARIO/Hello-World.git
cd Hello-World
git remote -v
Si clonaste el repo original y no puedes hacer push, cambia el remoto a tu fork: git remote set-url origin https://github.com/TUUSUARIO/tu-repo.git

Qué vas a hacer

Abrir una línea de trabajo paralela para no tocar main. Así podrás experimentar y después integrar.

  • Nombres útiles: feature/…, fix/…, hotfix/….
  • Comprueba la rama activa: git branch --show-current.
git checkout -b feature/cambios-propios
git branch --show-current

Qué vas a hacer

Crear/editar archivos, pasarlos a staging y registrar un commit con mensaje claro.

  • git add mueve cambios al área de preparación; git commit los guarda en el historial local.
  • Mensajes útiles: feat:, fix:, docs:, refactor:.
  • Deshacer staging: git restore --staged archivo. Ver estado: git status.
echo "Hola mundo desde mi rama" >> miarchivo.txt
git add miarchivo.txt
git commit -m "feat: agrega archivo de prueba"
git log --oneline -n 3

Qué vas a hacer

Integrar tu rama en la principal. Si aparecen conflictos, edítalos, prueba y confirma el merge.

  • Abortar merge si te equivocas: git merge --abort.
  • Recuperación avanzada: git reflog (historial de referencias).
git checkout main
git merge feature/cambios-propios

Qué vas a hacer

Enviar tus commits al remoto. La primera vez defines el upstream con -u.

  • Pull” = traer; Push = subir; Sync = ambos.
  • Solo avanzas si tu main local está al día (git pull --ff-only recomendado).
git push origin main
# Primera vez:
git push -u origin main

Qué vas a hacer

Crear una PR desde tu rama hacia main para revisión. En GitHub, usa Squash & merge para un historial limpio.

  • Incluye título descriptivo y checklist de lo que cambiaste.
# (Opcional) Con GitHub CLI instalada:
# gh pr create --base main --head feature/cambios-propios \
#   --title "Mi PR" --body "Descripción breve"

Qué vas a hacer

Apuntar tu remoto origin a tu fork para poder subir sin errores de permisos.

git remote set-url origin https://github.com/TUUSUARIO/tu-repo.git
git push -u origin main

Qué vas a hacer

Excluir dependencias y archivos del IDE para que el repositorio sea ligero y limpio.

  • Si ya subiste algo que debería ignorarse: git rm -r --cached carpeta → commit.
# Crea .gitignore y pega:
# Node
node_modules/
dist/
*.log

# IDEs
.vscode/
.idea/
*.iml

¿Qué es esta guía?

Un ejercicio completo en Markdown para simular un examen real de Git: crear repositorios, configurar identidad, commits, ramas, merge, resolución de conflictos y remoto. Ábrela en tu editor favorito o léela en el navegador con el visor integrado.

Nivel: inicio–medio 45–90 min Formato: .md
Descargar Guía Requiere cuenta GitHub solo para la parte remota
Cómo usarla paso a paso
  1. Descarga el archivo .md o ábrelo en el navegador con el botón de arriba.
  2. Crea una carpeta de trabajo vacía en tu equipo.
  3. Abre una terminal en esa carpeta (o la integrada de tu IDE preferido).
  4. Sigue los pasos de la guía en orden, ejecutando los comandos indicados.
  5. Para repetir el examen, crea otra carpeta limpia y vuelve a empezar.

Requisitos: Git instalado. Para practicar remoto, inicia sesión en GitHub.

Practica Git de forma visual (sin instalar nada)

Abre un simulador interactivo en español para entender y practicar ramas, commits y merges. Verás el grafo de commits en tiempo real y resolverás retos cortos.

Nivel: inicio–medio 10–20 min por reto Español
Abrir en nueva pestaña
Si tu navegador bloquea contenido embebido, usa “Abrir en nueva pestaña”.

Teoría y Práctica Interactiva de SQL · Guía Completa

¿Qué es SQL?

SQL (Structured Query Language) es el lenguaje estándar para gestionar y manipular bases de datos relacionales. Con él podemos crear estructuras de datos, insertar, consultar, actualizar y eliminar información en sistemas como MySQL, PostgreSQL, SQLite u Oracle.

¿Para qué sirve?
  • 📌 Definir y modificar estructuras con CREATE, ALTER o DROP.
  • ➕ Insertar datos nuevos con INSERT.
  • 🔎 Consultar información con SELECT, filtros, orden y agrupaciones.
  • ✏️ Modificar datos existentes con UPDATE.
  • 🗑️ Eliminar registros con DELETE.
  • 🔐 Controlar transacciones (COMMIT/ROLLBACK) y permisos (GRANT/REVOKE).

📘 ¿Qué es SQL? Es un lenguaje que te permite trabajar con bases de datos. Podrás consultar, insertar, modificar o eliminar información en tablas como alumnos.

📌 Ejemplos básicos para probar ahora:
  • 🟢 Ver todos los alumnos: SELECT * FROM alumnos;
  • ➕ Insertar un alumno nuevo: INSERT INTO alumnos (nombre, edad) VALUES ('Carlos', 19);
  • ✏️ Modificar un dato: UPDATE alumnos SET edad = 25 WHERE nombre = 'Ana';
  • 🗑️ Eliminar un registro: DELETE FROM alumnos WHERE nombre = 'Luis';
  • 🔠 Mostrar solo nombres: SELECT nombre FROM alumnos;
  • 📝 Mostrar nombre con alias: SELECT nombre AS Alumno FROM alumnos;
  • 🔎 Filtrar mayores de 20 años: SELECT * FROM alumnos WHERE edad > 20;
  • 📊 Ordenar por edad descendente: SELECT * FROM alumnos ORDER BY edad DESC;
  • 🔢 Mostrar solo 2 resultados: SELECT * FROM alumnos LIMIT 2;
  • ♻️ Ver edades únicas: SELECT DISTINCT edad FROM alumnos;

🧪 Práctica paso a paso:

Realiza estas acciones para afianzar lo aprendido. Puedes reiniciar la base si lo necesitas.

  1. 🟢 Muestra todos los alumnos: SELECT * FROM alumnos;
  2. ➕ Inserta un alumno nuevo (elige nombre y edad).
  3. ✏️ Modifica la edad de uno de los alumnos existentes.
  4. 🗑️ Elimina a un alumno por su nombre.
  5. 🔠 Muestra solo los nombres de los alumnos.
  6. 📝 Usa un alias para que el nombre aparezca como “Alumno”.
  7. 🔎 Muestra solo los alumnos mayores de 20 años.
  8. 📊 Ordena todos los alumnos de mayor a menor edad.
  9. 🔢 Muestra solo los 2 primeros registros.
  10. ♻️ Visualiza las edades únicas que hay en la tabla.

🧠 Con esto dominarás las consultas más comunes. Después de practicar esto, podrás avanzar al nivel medio con funciones como AVG, MAX, y subconsultas.

Historial de consultas:
    Consultas favoritas:

      Esta práctica reúne todo lo aprendido durante el curso, incluyendo teoría, ejemplos y ejercicios interactivos. Está pensada para alumnos de 1º y 2º DAW y permite repasar todos los conceptos fundamentales de SQL con datos reales.

      • 📌 Consultas básicas y filtrado
      • 🔗 JOIN entre tablas y funciones agregadas
      • 🧠 Subconsultas, cursores, triggers y procedimientos (teoría)
      • 🎯 Retos finales con soluciones guiadas

      Editor online con datos precargados para practicar todas las sentencias SQL de forma directa. Si no puedes interactuar, acepta las cookies en el recuadro de Programiz.

      ¿Qué es SELECT?

      SELECT es la sentencia fundamental en SQL que te permite consultar datos de una o varias tablas. Puedes mostrar todas las columnas con * o elegir campos concretos.

      En Programiz ya tienes precargada la tabla Customers con los campos: customer_id, first_name, last_name, age, country.

      🔹 1. Seleccionar columnas específicas
      SELECT first_name, age
      FROM Customers;
      🔹 2. Mostrar todos los campos
      SELECT *
      FROM Customers;
      🔹 3. Filtros con WHERE + operadores lógicos
      -- Clientes mayores de 25 años
      SELECT * FROM Customers WHERE age > 25;
      
      -- Clientes de USA o UK
      SELECT * FROM Customers
      WHERE country = 'USA' OR country = 'UK';
      
      -- Clientes de USA y mayores de 22
      SELECT * FROM Customers
      WHERE country = 'USA' AND age > 22;
      
      -- Clientes distintos de 'USA'
      SELECT * FROM Customers
      WHERE NOT country = 'USA';
      🔹 4. Ordenar resultados con ORDER BY
      -- Por edad descendente
      SELECT * FROM Customers
      ORDER BY age DESC;
      
      -- Por país (ascendente) y edad (descendente)
      SELECT * FROM Customers
      ORDER BY country ASC, age DESC;
      🔹 5. Eliminar duplicados con DISTINCT
      -- Ver países únicos
      SELECT DISTINCT country
      FROM Customers;
      🔹 6. Limitar resultados con LIMIT
      -- Mostrar los 3 primeros clientes
      SELECT * FROM Customers
      LIMIT 3;
      🎯 Retos guiados para practicar en Programiz

      Prueba a resolver estos retos directamente en el editor SQL:

      • 1. Mostrar solo los nombres de los clientes:
        SELECT first_name FROM Customers;
      • 2. Mostrar nombre y país de los clientes menores de 30:
        SELECT first_name, country FROM Customers WHERE age < 30;
      • 3. Ordenar clientes por país (A-Z) y edad (mayor a menor):
        SELECT * FROM Customers ORDER BY country ASC, age DESC;
      • 4. Mostrar clientes que no sean de USA:
        SELECT * FROM Customers WHERE NOT country = 'USA';
      • 5. Mostrar países únicos ordenados alfabéticamente:
        SELECT DISTINCT country FROM Customers ORDER BY country;
      • 6. Mostrar los 2 primeros clientes mayores de 22 años:
        SELECT * FROM Customers WHERE age > 22 LIMIT 2;

      ¿Qué es JOIN?

      Un JOIN permite combinar datos de varias tablas mediante una columna en común, como customer_id. En Programiz ya están precargadas las tablas Customers, Orders y Shippings.

      🔹 1. INNER JOIN (clientes y pedidos)

      Relaciona clientes con lo que han comprado:

      SELECT c.first_name, o.item
      FROM Customers c
      JOIN Orders o ON c.customer_id = o.customer_id;
      🔹 2. JOIN con 3 tablas (clientes, pedidos y envíos)

      Consulta más completa con estado del envío incluido:

      SELECT c.first_name, o.item, s.status
      FROM Customers c
      JOIN Orders o ON c.customer_id = o.customer_id
      JOIN Shippings s ON c.customer_id = s.customer;
      📊 3. Agrupar resultados con GROUP BY + funciones

      Úsalo con funciones como COUNT, SUM o AVG.

      -- Total gastado por cliente
      SELECT customer_id, SUM(amount) AS total
      FROM Orders
      GROUP BY customer_id;
      
      -- Nº de pedidos por cliente
      SELECT customer_id, COUNT(*) AS num_pedidos
      FROM Orders
      GROUP BY customer_id;
      🔸 4. Filtrar agrupaciones con HAVING

      HAVING se usa después de agrupar, cuando queremos filtrar los resultados agregados:

      -- Clientes con más de un pedido
      SELECT customer_id, COUNT(*) AS total
      FROM Orders
      GROUP BY customer_id
      HAVING total > 1;
      🎯 Retos guiados para practicar en Programiz
      1. SELECT + JOIN → Mostrar el nombre y producto pedido de cada cliente
        Relaciona Customers con Orders
        SELECT first_name, item FROM Customers JOIN Orders ...
      2. GROUP BY + COUNT → ¿Cuántos pedidos hizo cada cliente?
        Agrupa los pedidos por cliente y cuenta cuántos hay
        SELECT customer_id, COUNT(*) FROM Orders GROUP BY customer_id;
      3. SUM + ORDER BY → Total gastado por cliente (ordenado de mayor a menor)
        Suma los importes y ordénalos
        SELECT customer_id, SUM(amount) AS total FROM Orders GROUP BY customer_id ORDER BY total DESC;
      4. GROUP BY + HAVING → Clientes con más de 1 pedido
        Agrupa, cuenta y luego filtra
        SELECT customer_id, COUNT(*) FROM Orders GROUP BY customer_id HAVING COUNT(*) > 1;
      5. JOIN triple → Mostrar el nombre, producto y estado de envío de cada cliente
        Relaciona Customers + Orders + Shippings
        SELECT c.first_name, o.item, s.status FROM Customers c JOIN Orders o ON c.customer_id = o.customer_id JOIN Shippings s ON c.customer_id = s.customer;

      ❓ ¿Qué es una subconsulta?

      Una subconsulta es una consulta SQL anidada dentro de otra. Puede devolver un único valor, una tabla o una lista, y se usa en SELECT, FROM o WHERE.

      🔍 Subconsulta en WHERE

      Ejemplo: mostrar pedidos con un amount mayor que la media de todos los pedidos (tabla Orders):

      SELECT * 
      FROM Orders
      WHERE amount > (SELECT AVG(amount) FROM Orders);
      📋 Subconsulta en SELECT

      Ejemplo: mostrar el nombre y el total de pedidos que hizo cada cliente (tabla Customers y subconsulta en Orders):

      SELECT first_name,
             (SELECT COUNT(*) 
              FROM Orders o 
              WHERE o.customer_id = c.customer_id) AS pedidos
      FROM Customers c;
      🧱 Subconsulta como tabla temporal (en FROM)

      Permite crear una tabla intermedia a partir de una consulta:

      SELECT avg_por_cliente.customer_id, avg_por_cliente.total
      FROM (
        SELECT customer_id, AVG(amount) AS total
        FROM Orders
        GROUP BY customer_id
      ) AS avg_por_cliente;
      💡 Consejos:
      • Las subconsultas deben estar entre paréntesis.
      • Pueden usarse para comparar, filtrar o generar resultados complejos.
      • En Programiz funcionan correctamente las subconsultas simples y agrupadas.
      🎯 Retos guiados con subconsultas:
      1. Mostrar todos los pedidos cuyo importe sea superior al promedio:
        ➤ Usa SELECT AVG(amount) como subconsulta en WHERE.
      2. Ver clientes que han hecho más pedidos que el promedio:
        ➤ Usa COUNT(*) y HAVING con una subconsulta.
      3. Ver nombre de cliente y cantidad total de pedidos realizados:
        ➤ Usa SELECT con una subconsulta interna por cliente.
      4. Mostrar todos los productos pedidos por clientes de UK:
        ➤ Subconsulta: customer_id FROM Customers WHERE country = 'UK'
        ➤ Consulta principal sobre Orders.
      5. Obtener la edad del cliente con más pedidos:
        ➤ Subconsulta con GROUP BY y ORDER BY COUNT, luego consulta en Customers.

      1️⃣ Cliente con más pedidos realizados

      Usa JOIN, GROUP BY, COUNT(*) y ORDER BY + LIMIT.

      SELECT c.first_name, COUNT(o.order_id) AS total_pedidos
      FROM Customers c
      JOIN Orders o ON c.customer_id = o.customer_id
      GROUP BY c.customer_id
      ORDER BY total_pedidos DESC
      LIMIT 1;
      2️⃣ Clientes que no han hecho ningún pedido

      Busca con LEFT JOIN + WHERE o.order_id IS NULL.

      SELECT c.first_name
      FROM Customers c
      LEFT JOIN Orders o ON c.customer_id = o.customer_id
      WHERE o.order_id IS NULL;
      3️⃣ Producto más vendido (mayor número de pedidos)

      Agrupa por item y ordena por COUNT(*).

      SELECT item, COUNT(*) AS total
      FROM Orders
      GROUP BY item
      ORDER BY total DESC
      LIMIT 1;
      4️⃣ Clientes con pedidos entregados

      Relaciona Customers con Shippings y filtra por status = 'Delivered'.

      SELECT DISTINCT c.first_name
      FROM Customers c
      JOIN Shippings s ON c.customer_id = s.customer
      WHERE s.status = 'Delivered';
      5️⃣ Clientes que han gastado más de 500€ en total

      Suma los importes por cliente y filtra con HAVING.

      SELECT customer_id, SUM(amount) AS total
      FROM Orders
      GROUP BY customer_id
      HAVING total > 500;

      📥 INSERT: añadir registros

      Con INSERT INTO podemos agregar nuevos datos a una tabla. Podemos insertar uno o varios registros.

      -- Insertar un cliente
      INSERT INTO Customers (first_name, age, country)
      VALUES ('Lucía', 30, 'Spain');
      
      -- Insertar varios clientes a la vez
      INSERT INTO Customers (first_name, age, country)
      VALUES 
        ('Mario', 26, 'Italy'),
        ('Anna', 24, 'France');
      ✏️ UPDATE: modificar registros existentes

      UPDATE permite cambiar el valor de una o varias columnas. Siempre debe usarse con WHERE para evitar modificar toda la tabla.

      -- Cambiar el país de un cliente
      UPDATE Customers
      SET country = 'Germany'
      WHERE first_name = 'Mario';
      🗑 DELETE: eliminar registros

      DELETE FROM se usa para borrar registros. Es obligatorio añadir WHERE para evitar borrar todo.

      -- Borrar un cliente específico
      DELETE FROM Customers
      WHERE first_name = 'Anna';
      🎯 Retos paso a paso:
      • INSERT → Añade un nuevo cliente llamado "Carlos", de 35 años y de México.
        INSERT INTO Customers (...) VALUES (...);
      • INSERT múltiple → Inserta 2 clientes nuevos de USA con edades diferentes.
        INSERT INTO Customers (...) VALUES (...), (...);
      • UPDATE → Cambia la edad del cliente "Lucía" a 32.
        UPDATE Customers SET ... WHERE ...;
      • UPDATE múltiple → Cambia el país de todos los clientes de 'USA' a 'United States'.
        UPDATE Customers SET ... WHERE country = 'USA';
      • DELETE → Elimina el cliente llamado "Carlos".
        DELETE FROM Customers WHERE ...;
      • DELETE con condición → Borra todos los clientes menores de 20 años.
        DELETE FROM Customers WHERE age < 20;

      🔍 Esta sección está dedicada a las operaciones avanzadas de SQL que no se pueden ejecutar en entornos como Programiz. Por eso utilizamos sqlize.online, un entorno MySQL 8.0 totalmente funcional para probar:

      • TRIGGERS
      • CURSORES
      • STORED PROCEDURES
      • TRANSACCIONES (BEGIN, COMMIT, ROLLBACK)
      • VISTAS, GRANT, REVOKE y más.
      🛠️ ¿Cómo usar el entorno sqlize.online?
      🔹 Escribe el código SQL en el panel izquierdo.
      🔹 Pulsa Run SQL code para ver el resultado en el panel derecho.
      🔹 Puedes usar DELIMITER // cuando sea necesario para TRIGGERS o PROCEDURES.
      🔹 Asegúrate de tener seleccionada la opción MySQL 8.0 en el menú desplegable inferior.

      🧠 Abajo puedes probar directamente comandos avanzados como TRIGGERS, CURSORES o PROCEDURES usando un entorno MySQL 8.0 real.

      🔗 Abrir editor sqlize.online en otra pestaña

      Ideal si quieres trabajar con dos pantallas: código a la izquierda y teoría a la derecha.

      📘 ¿Qué es un TRIGGER?

      Un Trigger es una instrucción que se ejecuta automáticamente cuando ocurre un evento (INSERT, UPDATE, DELETE) en una tabla. Sirve para auditar, registrar cambios o automatizar tareas internas sin necesidad de que el usuario lo llame manualmente.

      🧱 1. Crear estructura base

      En sqlize.online, copia este bloque en el panel izquierdo (Schema SQL). Aquí creamos las tablas necesarias e insertamos datos:

      -- Crear tabla principal de alumnos
      CREATE TABLE alumnos (
        id INT AUTO_INCREMENT PRIMARY KEY,
        nombre VARCHAR(100),
        edad INT
      );
      
      -- Insertar algunos alumnos de prueba
      INSERT INTO alumnos (nombre, edad) VALUES
      ('Lucía', 21),
      ('Miguel', 23),
      ('Aitana', 20);
      
      -- Crear tabla de log para registrar las inserciones
      CREATE TABLE log_insert (
        id INT AUTO_INCREMENT PRIMARY KEY,
        mensaje TEXT,
        fecha DATETIME
      );
      ⚙️ 2. Crear el Trigger

      Este trigger se ejecuta automáticamente después de cada INSERT en la tabla alumnos. Registra un mensaje en log_insert con el nombre y la edad del nuevo alumno.

      En sqlize.online debes usar DELIMITER // para definir el bloque del trigger. En MySQL Workbench u otros gestores también es obligatorio cuando hay múltiples líneas.

      DELIMITER //
      
      CREATE TRIGGER log_nuevo_alumno
      AFTER INSERT ON alumnos
      FOR EACH ROW
      BEGIN
        INSERT INTO log_insert (mensaje, fecha)
        VALUES (
          CONCAT('Nuevo alumno insertado: ', NEW.nombre, ', edad ', NEW.edad),
          NOW()
        );
      END;
      //
      
      DELIMITER ;
      ✅ 3. Probar el Trigger

      Una vez hayas copiado la estructura de las tablas y creado el trigger, puedes ejecutar este código para comprobar que el trigger funciona correctamente.

      Simplemente añade este bloque al final del código anterior en sqlize.online y pulsa Run SQL code. Así insertarás un nuevo alumno y verás cómo el trigger actúa automáticamente registrando la operación.

      -- Insertar un nuevo alumno
      INSERT INTO alumnos (nombre, edad) VALUES ('Eva', 22);
      
      -- Verificar si el trigger registró el cambio
      SELECT * FROM log_insert;
      ¿Por qué funciona?
      Al insertar un nuevo alumno, el TRIGGER se ejecuta automáticamente y guarda el mensaje en la tabla log_insert. No hace falta llamarlo manualmente. Puedes probar con más inserciones para ver cómo se comporta.
      🎯 Retos sugeridos (continúan con la tabla alumnos)

      Ahora que ya tienes un trigger AFTER INSERT funcionando, puedes ampliarlo con más lógica útil:

      • 🗑 Trigger AFTER DELETE: Registra en log_insert cada vez que se borre un alumno.
        💡 Usa: OLD.nombre en el mensaje.
      • 📊 Tabla resumen: Crea una tabla resumen con total_alumnos. Usa triggers para actualizarla:
        • 🔺 Tras INSERT: suma 1.
        • 🔻 Tras DELETE: resta 1.
      • Incluir día de la semana: Añade DAYNAME(NOW()) en el log.
        👉 O crea una columna nueva como dia_semana.
      • ✏️ AFTER UPDATE: Guarda los cambios de edad en una tabla log_update.
        Registra: nombre, OLD.edad, NEW.edad y fecha.
      • 🧪 Test combinado:
        1. Inserta 3 alumnos nuevos
        2. Borra 1
        3. Actualiza la edad de otro

        ✅ Comprueba que los logs reflejan correctamente los tres eventos.

      📘 ¿Qué es un CURSOR?

      Un Cursor en SQL te permite recorrer fila a fila el resultado de una consulta. Se utiliza cuando necesitas aplicar lógica secuencial a múltiples registros.

      Junto con DECLARE, OPEN, FETCH y CLOSE, puedes controlar el flujo de lectura de los datos como si fuera un bucle.

      🧱 1. Crear estructura base

      En sqlize.online, usa este bloque para crear las tablas y añadir datos de ejemplo:

      -- Tabla base de alumnos
      CREATE TABLE alumnos (
        id INT AUTO_INCREMENT PRIMARY KEY,
        nombre VARCHAR(100),
        edad INT
      );
      
      -- Insertar registros
      INSERT INTO alumnos (nombre, edad) VALUES
      ('Lucía', 21),
      ('Miguel', 23),
      ('Aitana', 20);
      
      -- Tabla para almacenar el log de mayores de edad
      CREATE TABLE mayores_edad (
        id INT AUTO_INCREMENT PRIMARY KEY,
        nombre VARCHAR(100)
      );
      ⚙️ 2. Crear procedimiento con CURSOR

      Este procedimiento recorrerá la tabla alumnos y copiará los nombres con edad mayor o igual a 21 a la tabla mayores_edad.

      DELIMITER //
      
      CREATE PROCEDURE insertar_mayores()
      BEGIN
        DECLARE done INT DEFAULT FALSE;
        DECLARE v_nombre VARCHAR(100);
        DECLARE v_edad INT;
        DECLARE cur CURSOR FOR SELECT nombre, edad FROM alumnos;
        DECLARE CONTINUE HANDLER FOR NOT FOUND SET done = TRUE;
      
        OPEN cur;
      
        leer_loop: LOOP
          FETCH cur INTO v_nombre, v_edad;
          IF done THEN 
            LEAVE leer_loop;
          END IF;
      
          IF v_edad >= 21 THEN
            INSERT INTO mayores_edad(nombre) VALUES (v_nombre);
          END IF;
        END LOOP;
      
        CLOSE cur;
      END;
      //
      
      DELIMITER ;
      ✅ 3. Ejecutar y probar

      Este código invoca el procedimiento para poblar la tabla mayores_edad:

      -- Ejecutar el procedimiento
      CALL insertar_mayores();
      
      -- Ver resultado
      SELECT * FROM mayores_edad;
      ¿Qué hace?
      Recorre la tabla alumnos, y si la edad es mayor o igual a 21, añade el nombre a mayores_edad.
      🎯 Retos sugeridos
      🎯 Retos ampliados con cursores
      • 📄 Guardar nombre y edad:
        Modifica el procedimiento para que además de nombre, también se almacene edad en mayores_edad.
        Ayuda: añade una columna edad INT en la tabla destino y actualiza el INSERT INTO:
        INSERT INTO mayores_edad(nombre, edad) VALUES (v_nombre, v_edad);
      • 🔁 Filtrar por edad entre 22 y 25 años:
        Añade una condición que solo copie alumnos cuya edad esté en ese rango. Usa un segundo IF dentro del bucle:
        IF v_edad BETWEEN 22 AND 25 THEN ...
      • 💾 Registrar en log_cursor:
        Crea una nueva tabla log_cursor con columnas nombre, edad y fecha.
        Registra cada alumno insertado con la fecha actual usando NOW():
        INSERT INTO log_cursor(nombre, edad, fecha) VALUES (v_nombre, v_edad, NOW());
      • ⚠️ Manejo de datos nulos:
        Asegúrate de que v_nombre y v_edad no sean nulos antes de insertarlos. Puedes usar:
        IF v_nombre IS NOT NULL AND v_edad IS NOT NULL THEN ...
      • 🧽 Evitar duplicados:
        Borra el contenido de mayores_edad al inicio del procedimiento para que no se acumulen los datos en cada ejecución:
        DELETE FROM mayores_edad;
      • 🧪 Prueba completa combinada:
        • 1. Inserta 3 alumnos con distintas edades.
        • 2. Llama al procedimiento.
        • 3. Verifica el contenido de mayores_edad y log_cursor si lo has creado.
        • 4. Modifica edades y vuelve a ejecutar para ver los efectos.

      📘 ¿Qué es un Stored Procedure?

      Un procedimiento almacenado es un bloque de instrucciones SQL que se guarda en la base de datos y puede ejecutarse con una sola llamada. Es útil para automatizar tareas, mejorar el rendimiento y mantener la lógica centralizada en el servidor.

      🧱 1. Crear estructura inicial

      Copia este bloque para crear las tablas necesarias:

      -- Tabla principal de alumnos
      CREATE TABLE alumnos (
        id INT AUTO_INCREMENT PRIMARY KEY,
        nombre VARCHAR(100),
        edad INT
      );
      
      INSERT INTO alumnos (nombre, edad) VALUES
      ('Lucía', 21),
      ('Pedro', 26),
      ('Aitana', 24),
      ('David', 30);
      
      -- Tabla destino para guardar alumnos mayores de edad
      CREATE TABLE mayores_edad (
        id INT AUTO_INCREMENT PRIMARY KEY,
        nombre VARCHAR(100)
      );
      ⚙️ 2. Crear el procedimiento

      Este procedimiento recorre los alumnos y copia los mayores de 25 años en la tabla mayores_edad.

      DELIMITER //
      
      CREATE PROCEDURE copiarMayores()
      BEGIN
        DELETE FROM mayores_edad;
      
        INSERT INTO mayores_edad (nombre)
        SELECT nombre
        FROM alumnos
        WHERE edad > 25;
      END;
      //
      
      DELIMITER ;
      ✅ 3. Ejecutar el procedimiento

      Llama al procedimiento con una simple sentencia:

      -- Ejecutar el procedimiento
      CALL copiarMayores();
      
      -- Ver resultados
      SELECT * FROM mayores_edad;
      💡 ¿Qué hace esto?
      Borra todos los registros anteriores y vuelve a insertar solo los alumnos con edad superior a 25. Ideal para mantener la tabla mayores_edad siempre actualizada.
      🎯 Retos sugeridos (Stored Procedures)
      • 📄 Añade una condición para guardar solo si edad está entre 22 y 30.
      • 💾 Guarda también la edad junto al nombre en mayores_edad.
      • 🔁 Usa un CURSOR dentro del procedimiento para recorrer uno a uno los alumnos.
      • ⚠️ Usa IF NULL para evitar errores con datos incompletos.
      • 🧹 Añade un DELETE al principio para limpiar la tabla destino antes de insertar.
      • 📊 Guarda los resultados también en una tabla log_procedure con nombre, edad y fecha.

      📘 ¿Qué es una Transacción?

      Una transacción es un conjunto de operaciones SQL que se ejecutan como una unidad. Si todas tienen éxito, se CONFIRMA con COMMIT. Si ocurre un error, se CANCELA con ROLLBACK. Son esenciales para mantener la integridad de los datos.

      🧱 1. Crear estructura base

      Copia esta estructura para probar la transacción:

      -- Tabla de cuentas bancarias
      CREATE TABLE cuentas (
        id INT AUTO_INCREMENT PRIMARY KEY,
        nombre VARCHAR(100),
        saldo DECIMAL(10,2)
      );
      
      -- Insertar cuentas de ejemplo
      INSERT INTO cuentas (nombre, saldo) VALUES
      ('Carlos', 500.00),
      ('Ana', 300.00);
      ⚙️ 2. Transacción correcta

      Este bloque simula una transferencia de 100€ entre dos cuentas. Todo se ejecuta o nada, según el resultado.

      START TRANSACTION;
      
      UPDATE cuentas SET saldo = saldo - 100 WHERE nombre = 'Carlos';
      UPDATE cuentas SET saldo = saldo + 100 WHERE nombre = 'Ana';
      
      COMMIT;
      
      -- Verificar resultado
      SELECT * FROM cuentas;
      ❌ 3. Transacción con error y ROLLBACK

      Este ejemplo falla porque la segunda cuenta no existe. Se deshace todo con ROLLBACK.

      START TRANSACTION;
      
      UPDATE cuentas SET saldo = saldo - 100 WHERE nombre = 'Carlos';
      UPDATE cuentas SET saldo = saldo + 100 WHERE nombre = 'PersonaInexistente';
      
      ROLLBACK;
      
      -- Verificar resultado
      SELECT * FROM cuentas;
      💡 ¿Qué ha pasado?
      Como el segundo UPDATE no afecta a ninguna fila, decidimos cancelar toda la operación. El saldo de Carlos sigue igual.
      🎯 Retos propuestos con transacciones
      • 🏦 Crea una tabla log_transacciones con nombre, cantidad y fecha. Añade un INSERT al final de cada transacción exitosa.
      • ⛔ Añade una condición para hacer ROLLBACK si el saldo final queda negativo.
      • 🔁 Simula varias transferencias dentro de una única transacción.
      • 📉 Intenta transferir más dinero del que tiene una cuenta y cancela con ROLLBACK.
      • 🧪 Crea una Stored Procedure que realice transferencias seguras con lógica de ROLLBACK incluida.

      📘 ¿Qué es una VIEW?

      Una vista es una tabla virtual basada en el resultado de una consulta SELECT. No almacena datos por sí misma, pero permite acceder a los datos como si fuera una tabla real. Sirve para simplificar consultas, proteger información o reutilizar lógica compleja.

      🧱 Crear una vista básica

      Esta vista muestra solo los alumnos mayores de edad:

      CREATE VIEW alumnos_mayores AS
      SELECT nombre, edad
      FROM alumnos
      WHERE edad >= 18;
      🔍 Consultar la vista
      SELECT * FROM alumnos_mayores;
      🎯 Retos sugeridos con vistas
      • 🔐 Crea una vista que muestre solo los nombres de alumnos, ocultando la edad.
      • 📊 Crea una vista que calcule el promedio de edad de los alumnos.
      • 📅 Si tienes fechas en alguna tabla, crea una vista con registros del último mes.
      • 🧩 Usa una vista con JOIN para unir la tabla alumnos con otra (como log_insert).
      • ✏️ Prueba a modificar la vista con CREATE OR REPLACE VIEW.

      📘 ¿Qué son los permisos en MySQL?

      Los permisos en MySQL determinan qué acciones puede realizar un usuario sobre una base de datos. Se otorgan mediante el comando GRANT y se revocan con REVOKE. Se pueden aplicar a nivel de base de datos, tabla o columna.

      👤 Crear un usuario

      Puedes crear un nuevo usuario y definir su contraseña. Ejemplo:

      CREATE USER 'usuario_prueba'@'localhost' IDENTIFIED BY 'miclave123';
      🎁 Conceder permisos

      Para dar acceso a una base de datos o tabla concreta:

      GRANT SELECT, INSERT, UPDATE ON nombre_base_datos.* TO 'usuario_prueba'@'localhost';
      ❌ Revocar permisos

      Puedes retirar privilegios con REVOKE:

      REVOKE INSERT, UPDATE ON nombre_base_datos.* FROM 'usuario_prueba'@'localhost';
      🔍 Ver privilegios de un usuario
      SHOW GRANTS FOR 'usuario_prueba'@'localhost';
      🎯 Retos sugeridos sobre permisos
      • 🧪 Crea un usuario solo con permiso de lectura (SELECT) sobre la tabla alumnos.
      • 🔐 Intenta ejecutar un DELETE con ese usuario y verifica que no tiene permiso.
      • ✏️ Dale permisos temporales y luego revócalos tras una operación.
      • 👥 Crea varios usuarios con diferentes niveles de acceso a la base de datos.
      • 🔄 Usa FLUSH PRIVILEGES si modificas manualmente los permisos.

      Este glosario te ayudará a repasar los términos más usados de SQL. Agrupados por categorías, con ejemplos y explicaciones claras. ¡Ideal para repasar antes de un examen!

      📌 Término 🧠 Significado 🧪 Ejemplo
      🧱 Definición de estructuras
      CREATE TABLE Crea una tabla nueva con columnas. CREATE TABLE alumnos (id INT, nombre VARCHAR(50));
      PRIMARY KEY Define una columna como identificador único. id INT PRIMARY KEY
      📥 Inserción de datos
      INSERT INTO Inserta una nueva fila en la tabla. INSERT INTO alumnos (nombre, edad) VALUES ('Ana', 20);
      🔍 Consultas
      SELECT Recupera datos de una o más tablas. SELECT * FROM alumnos;
      WHERE Filtra los resultados según condición. SELECT * FROM alumnos WHERE edad > 21;
      ⚙️ Automatización y lógica
      TRIGGER Ejecuta código automáticamente tras un evento (INSERT, DELETE, UPDATE). AFTER INSERT ON alumnos...
      PROCEDURE Bloque de código reutilizable con lógica compleja. CREATE PROCEDURE actualizarEdad()...
      CURSOR Permite recorrer resultados fila a fila. DECLARE cursor_alumnos CURSOR FOR SELECT * FROM alumnos;
      🧰 Funciones y extras
      NOW() Devuelve la fecha y hora actuales. INSERT INTO log VALUES (..., NOW());
      CONCAT() Une varios textos en uno solo. CONCAT('Hola ', nombre)

      Clase de prueba: programa tu primera vez en Java

      Descarga una clase gratuita y mira cómo trabajamos en este curso. También puedes probar el ejercicio directamente desde la página, sin instalar nada.
      Esta clase te enseñará a declarar variables, usar if y for.

      📄 Archivo .java: Código fuente que puedes abrir en Visual Studio Code o cualquier otro IDE para compilarlo y probarlo.

      📘 Archivo .md: Guía explicativa con teoría, instrucciones paso a paso y ejercicios. Abre con VS Code o cualquier lector Markdown.

      🤖 Programa con Inteligencia Artificial

      Elige un lenguaje, el nivel y describe libremente el ejercicio que quieres practicar.
      Luego, genera un ejemplo único con inteligencia artificial y pruébalo directamente en el editor integrado.

      💡 Ejercicio generado por IA
      Generando respuesta...
      
                  

      🔗 Si lo prefieres, puedes abrir el editor online de Programiz en otra pestaña para trabajar cómodamente:

      Puedes editar el código generado y ejecutarlo al instante. El compilador se adapta automáticamente al lenguaje seleccionado.

      Pregúntale a la IA