Cursos disponibles
Entra directo al temario, descargas y practica guiada. Si empiezas desde cero, empieza por Web.
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.
Curso de Python
Aprende desde cero con teoría explicada, editor en vivo y archivos descargables (.py y .md)
Entrar al cursoJava desde Cero · Teoría y Práctica
Teoría completa, prácticas guiadas, tests interactivos y proyecto final.
Ir al cursoImpacto 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 etiquetasCSS
Estilos y diseñoJavaScript
InteractividadBootstrap
ComponentesInstala Live Server
Abre VS Code → Extensiones (Ctrl+Shift+X) → Busca "Live Server" → Instalar.
Extensión gratuitaAbre tu archivo .html
Descarga un .html del curso → Abre con VS Code → Clic derecho → Open with Live Server.
Se abre en el navegadorCómo usar los materiales del curso
- Descarga el archivo
.htmlde la unidad que quieras practicar. - Abre VS Code y arrastra el archivo o usa Archivo → Abrir.
- Clic derecho en el código → Open with Live Server.
- Edita el código y guarda (Ctrl+S). La página se actualiza sola.
- 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!
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 atributoalt). - 🔗 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 luegoh2/h3en orden), poner texto alternativo a las imágenes y usar atributos comoaria-labeloaria-labelledbycuando sea necesario para que todos los usuarios puedan navegar sin problemas.
⏳ Cargando código...
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
colorybackground-colordecides 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 comopxorempara 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) ybox-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.
⏳ Cargando código...
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.
⏳ Cargando código...
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.jsenlazado. 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.querySelectorseleccionas un elemento y contextContent,classListosetAttributelo 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.
⏳ Cargando código...
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-themeen<body>. La preferencia del usuario se guarda enlocalStoragepara 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
altyaria-*, contrastes y CTA. Además, detectar mejoras rápidas de UX, SEO y rendimiento.
⏳ Cargando código...
✅ Pasos (modo rápido)
- Crea una carpeta en tu PC (por ejemplo
mi-web). - Dentro debe existir un archivo llamado
index.html(es el “inicio” de tu web). - Prueba en local: abre
index.htmlo usa Live Server en VS Code. - Entra en Netlify Drop y arrastra la carpeta (o el
index.html). - Netlify te da una URL: abre el enlace, revisa y compártelo.
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.
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.
git push.
Zona Práctica Interactiva
Editor en vivo para practicarSelecciona 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.
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.
Paso 1 · Instalar Java (JDK)
Instala JDK 17 o superior. Recomendado: Temurin (Adoptium), que se instala con asistente (siguiente, siguiente...).
Descargar Temurin JDKPaso 2 · Editor recomendado
Usa Visual Studio Code para abrir los archivos del curso y trabajar cómodo.
Descargar VS CodeExtensiones recomendadas (VS Code)
- Java Extension Pack: compilar, ejecutar y depurar Java.
- Better Comments: mejora la lectura de comentarios.
.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) ychar(carácter). -
🧮 Operadores aritméticos:
+-*/%. Comparación:==!=<<=>>=. Lógicos:&&(y),||(o),!(no). -
📝 Buenas prácticas:
nombres en camelCase (
precioTotal), evita abreviaturas confusas, inicializa variables, usafinalpara constantes y comenta lo imprescindible. - ✅ Objetivo: al terminar, podrás declarar variables, combinarlas en expresiones y decidir el tipo correcto para cada dato.
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/elseyelse ifpara controlar casos diferentes. -
📋 Decisiones por casos usando
switchycasepara 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 consideraswitchpara 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
newy acceso a métodos - 🧬 Herencia con
extendsy uso desuper - 🧠 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
throwythrows - 📘 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,indexOfyreplace - 🔠 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
foryforeach - 🧩 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
LocalTimeyDuration - 📘 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
Zona Práctica Interactiva (Java)
Elige una UT, copia el código y ejecútalo en ProgramizElige una unidad para cargar el ejercicio real del curso. Copia el código y pégalo en el compilador de abajo.
public class Main {
public static void main(String[] args) {
System.out.println(\"Elige una UT arriba 👆\");
}
}
Curso completo de Python · Aprende desde cero
¿Por qué aprender Python?
Python es un lenguaje moderno y muy demandado, perfecto para empezar por su sintaxis clara. Se usa en IA, web, automatización y datos.
Herramientas necesarias
-
Python 3.10 o superiorDescargar desde la web oficial
-
Visual Studio Code (recomendado)Descargar VS Code
-
Extensiones recomendadasPython, Better Comments
- 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.
- Variables y nombres: qué son,
snake_case, reasignación y buenas prácticas. - Tipos básicos:
int,float,str,booly 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.
- 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.
- 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) ybool(). - Ternario: decisiones compactas en una línea (
"OK" if cond else "NO"). - match / case (3.10+): múltiples ramas legibles con comodín
case _.
- 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.
- 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,continuey else en bucles. - Bucles anidados: tablas de multiplicar y cuadrículas simples.
- Comprensiones de listas: generar listas en una línea con filtro.
- 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.
- 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.
- 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.
- 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.
- 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.
- 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
Construir programas robustos que no se caigan ante errores, muestren mensajes claros y cierren recursos de forma segura.
try/exceptbásico: capturar y tratar errores esperados- Múltiples
excepty jerarquía de excepciones elseyfinally: flujos de éxito y limpiezaraisey validación con mensajes descriptivos- Excepciones personalizadas para tu dominio
- Reintento seguro con intentos limitados
Resumen de la unidad
Aprender a organizar y reutilizar código mediante módulos propios y librerías externas de Python.
importyfrom ... 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
Dominar la lectura y escritura de archivos en Python: texto, CSV, JSON y binarios.
open(),read(),write()- Context manager
withpara archivos - Modos de apertura:
r,w,a,b - Trabajar con CSV y JSON
- Manejo de rutas con
os.pathypathlib
Resumen de la unidad
Crear scripts de automatización para tareas del sistema operativo y administración.
- Módulo
osyshutilpara 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
Conectar Python con bases de datos SQLite para almacenar y consultar información persistente.
- Módulo
sqlite3de 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
Escribir tests automáticos y depurar código de forma eficiente para garantizar calidad.
- Módulo
unittestypytest - Escribir tests unitarios y de integración
- Debugger
pdby breakpoints - Logging y trazas de errores
- TDD: Test Driven Development básico
Resumen de la unidad
Dominar Flask, el microframework web más popular de Python. Desde lo básico hasta proyectos completos con estructura profesional.
- 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 completotemplates/- 4 plantillas HTMLREADME.md- Documentación
Proyecto Avanzado
Estructura profesional con Blueprints, MVC y configuración separada.
app.py- Punto de entradaconfig.py- Configuraciónmodels.py- Modelos de datosroutes/- Blueprintstemplates/- Vistas
Resumen de la unidad
Dominar Django, el framework web "batteries included" de Python. Aprenderás desde la configuración inicial hasta desplegar un proyecto completo.
- 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óndjpf/- Configuraciónsettings.pyurls.py
core/- App principalviews.pytemplates/middleware.py
Documentación Extra
Guías complementarias para profundizar en Django.
Práctica integradora
Aplicar de forma integrada todos los conocimientos aprendidos mediante una simulación realista de administración de servidores.
- 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.
Java desde Cero · Teoría y Práctica
Variables y Tipos de Datos
Las variables almacenan datos que usaremos en el programa. Cada una tiene un tipo.
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);
}
}
final para constantes que no cambian.
Condicionales
Ejecutan código solo si se cumple una condición.
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");
}
}
}
Bucles
Repiten instrucciones múltiples veces.
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
}
}
}
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");
}
}
Arrays
Almacenan múltiples valores del mismo tipo.
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
Programación Orientada a Objetos
Organiza el código en clases con atributos y métodos.
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();
}
}
Herencia y Polimorfismo
Una clase puede heredar de otra con extends.
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();
}
}
Excepciones
Permiten manejar errores sin detener el programa.
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");
}
}
}
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
.javacon la práctica base con comentarios para rellenar. - 📘 Un archivo
.mdcon 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 nombreint edad→ Guarda tu edadboolean 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
¿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 elif.
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:comparadia == X.break;detiene el switch tras ejecutar ese bloque.default:bloque por defecto si ningúncasecoincide.
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:Suspenso5–6:Aprobado7–8:Notable9–10:Sobresaliente
Sigue estos pasos en tu IDE o editor preferido:
- Lee la nota con
Scanner. - Guarda la entrada en una variable
int nota. - Usa
if / else if / elseoswitchpara clasificar la nota. - 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
¿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:
- Crea una clase Java con
public static void main. - Usa un bucle
fordonde:int i = 1(inicio)i <= 10(condición)i++(actualización)
- 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
¿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:
- Define una clase
Votacion. - Dentro, crea
public static boolean puedeVotar(int edad). - Usa
return edad >= 18;. - En el
main, llama apuedeVotarcon distintas edades y muéstralo.
Test interactivo: Funciones y Métodos
¿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(): devuelvetruesianio < 2010.
Después, en Main, instancia un Coche, asígnale valores, y
llama ambos métodos.
Test interactivo: Clases y Objetos
¿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.lengthda el número total de elementos - 📌 Los índices van de
0alength - 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
¿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:
- Cree un
Listcon números:[5, 3, 8, 3, 5]. - Use un
Setpara eliminar duplicados. - Ordene los números únicos de menor a mayor (convierte a
TreeSet). - Convierta ese
TreeSetenListy muéstrelo.
Test interactivo: Colecciones
¿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
RuntimeExceptiony 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:
- Pida al usuario dos números enteros (
ayb). - Intente dividir
aentreb. - Si
bes cero, capture la excepción y muestre: "No puedo dividir por cero, prueba con otro divisor." - 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
¿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 ampliarGestorAlumnos.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?
- Abre la carpeta que contiene
GestorAlumnos.java - Instala la extensión Java Extension Pack
- Haz clic derecho sobre el archivo y selecciona Run Java
- Verás el menú interactivo en la consola inferior
- Abre el proyecto o importa la carpeta donde está el código
- Haz clic en
GestorAlumnos.java - Pulsa el botón verde ▶️ o botón derecho > Run
- Se abrirá la consola con el menú interactivo
- Crea un proyecto nuevo tipo "Java con Ant"
- Pega el archivo
GestorAlumnos.javaen la carpetasrc - 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.
Carpeta de tu proyecto + una subcarpeta oculta
.git con el historial.
Una foto de tus cambios con un mensaje que los describe.
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.
¿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).
📁 Working Directory
Tus archivos “sin guardar en Git”.
- Estado: untracked / modified
- Avanza con: git add
- Revisa: git status
🧺 Staging Area
“Cesta” de cambios listos para confirmar.
- Confirma: git commit -m "mensaje"
- Quita del staging: git restore --staged …
📚 Repository (local)
Historial de commits en tu PC.
- Ver: git log --oneline --graph
- Subir: git push
- Recuperar: git reflog
☁️ Remote (GitHub/GitLab)
Copia compartida en la nube.
- Bajar: git pull --ff-only
- Traer refs: git fetch
- Enlazar: git push -u origin main
- 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)
- Branch: línea de trabajo (
main,feature/x) - HEAD: tu “puntero” actual
- Upstream: la rama remota asociada (git push -u)
- Entiendo las 4 cajas: Working, Staging, Local, Remote.
- Sé los pasos básicos: add → commit → push / pull.
- Trabajaré en
mainy 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
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
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
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
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
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>
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
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
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 verseorigin). - 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
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 addmueve cambios al área de preparación;git commitlos 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
mainlocal está al día (git pull --ff-onlyrecomendado).
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.
Cómo usarla paso a paso
- Descarga el archivo
.mdo ábrelo en el navegador con el botón de arriba. - Crea una carpeta de trabajo vacía en tu equipo.
- Abre una terminal en esa carpeta (o la integrada de tu IDE preferido).
- Sigue los pasos de la guía en orden, ejecutando los comandos indicados.
- 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.
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,ALTERoDROP. - ➕ 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.
- 🟢 Muestra todos los alumnos:
SELECT * FROM alumnos; - ➕ Inserta un alumno nuevo (elige nombre y edad).
- ✏️ Modifica la edad de uno de los alumnos existentes.
- 🗑️ Elimina a un alumno por su nombre.
- 🔠 Muestra solo los nombres de los alumnos.
- 📝 Usa un alias para que el nombre aparezca como “Alumno”.
- 🔎 Muestra solo los alumnos mayores de 20 años.
- 📊 Ordena todos los alumnos de mayor a menor edad.
- 🔢 Muestra solo los 2 primeros registros.
- ♻️ 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
-
SELECT + JOIN → Mostrar el nombre y producto pedido de cada
cliente
Relaciona Customers con Orders
SELECT first_name, item FROM Customers JOIN Orders ... -
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; -
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; -
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; -
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:
-
Mostrar todos los pedidos cuyo importe sea superior al promedio:
➤ UsaSELECT AVG(amount)como subconsulta enWHERE. -
Ver clientes que han hecho más pedidos que el promedio:
➤ UsaCOUNT(*)yHAVINGcon una subconsulta. -
Ver nombre de cliente y cantidad total de pedidos realizados:
➤ UsaSELECTcon una subconsulta interna por cliente. -
Mostrar todos los productos pedidos por clientes de UK:
➤ Subconsulta:customer_id FROM Customers WHERE country = 'UK'
➤ Consulta principal sobreOrders. -
Obtener la edad del cliente con más pedidos:
➤ Subconsulta conGROUP BYyORDER BY COUNT, luego consulta enCustomers.
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:
TRIGGERSCURSORESSTORED PROCEDURESTRANSACCIONES(BEGIN,COMMIT,ROLLBACK)VISTAS,GRANT,REVOKEy más.
🔹 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.
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;
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_insertcada vez que se borre un alumno.
💡 Usa:OLD.nombreen el mensaje. - 📊 Tabla resumen: Crea una tabla
resumencontotal_alumnos. Usa triggers para actualizarla:- 🔺 Tras
INSERT: suma 1. - 🔻 Tras
DELETE: resta 1.
- 🔺 Tras
- ⏰ Incluir día de la semana: Añade
DAYNAME(NOW())en el log.
👉 O crea una columna nueva comodia_semana. - ✏️ AFTER UPDATE: Guarda los cambios de edad en una tabla
log_update.
Registra: nombre,OLD.edad,NEW.edady fecha. - 🧪 Test combinado:
- Inserta 3 alumnos nuevos
- Borra 1
- Actualiza la edad de otro
✅ Comprueba que los
logsreflejan 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;
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 denombre, también se almaceneedadenmayores_edad.
Ayuda: añade una columnaedad INTen la tabla destino y actualiza elINSERT 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 segundoIFdentro del bucle:IF v_edad BETWEEN 22 AND 25 THEN ...
-
💾 Registrar en log_cursor:
Crea una nueva tablalog_cursorcon columnasnombre,edadyfecha.
Registra cada alumno insertado con la fecha actual usandoNOW():INSERT INTO log_cursor(nombre, edad, fecha) VALUES (v_nombre, v_edad, NOW());
-
⚠️ Manejo de datos nulos:
Asegúrate de quev_nombreyv_edadno 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 demayores_edadal 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_edadylog_cursorsi 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;
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
edadestá entre 22 y 30. - 💾 Guarda también la
edadjunto al nombre enmayores_edad. - 🔁 Usa un
CURSORdentro del procedimiento para recorrer uno a uno los alumnos. - ⚠️ Usa
IF NULLpara evitar errores con datos incompletos. - 🧹 Añade un
DELETEal principio para limpiar la tabla destino antes de insertar. - 📊 Guarda los resultados también en una tabla
log_procedurecon 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;
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_transaccionescon nombre, cantidad y fecha. Añade unINSERTal final de cada transacción exitosa. - ⛔ Añade una condición para hacer
ROLLBACKsi 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 Procedureque 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
JOINpara unir la tablaalumnoscon otra (comolog_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 tablaalumnos. - 🔐 Intenta ejecutar un
DELETEcon 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 PRIVILEGESsi 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
🔗 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.