Saltar a contenido

13. Ejercicios y actividades

UD3 — Control de Flujo y Depuración · RA3 — Escribe y depura código, analizando y utilizando las estructuras de control del lenguaje

IES Thiar — Pilar de la Horadada (Alicante) · Curso 2026-2027

Aspecto Valor
Resultado de aprendizaje RA: 3 — Escribe y depura código, analizando y utilizando las estructuras de control del lenguaje.
Criterios de evaluación a los que contribuye esta sección CE 3.1 · CE 3.2 · CE 3.3 · CE 3.4 · CE 3.5 · CE 3.6 · CE 3.7 · CE 3.8 · CE 3.9 (todos los criterios de RA3).
Marco normativo RD 405/2023 · RD 450/2010 · RD 659/2023
Tecnología base Java 25 LTS (OpenJDK Temurin 25) — IntelliJ IDEA Community Edition
Horas estimadas ~4 h (de las 30 h de la UD3).

Requisitos previos (lo que ya sabes): todas las secciones de UD3, de la 1 a la 12. Has completado el test de repaso de la sección 12. Si has fallado más de 2 preguntas en algún bloque del test, repasa esa sección antes de hacer los ejercicios de este bloque.

Cómo usar esta sección: los ejercicios están ordenados por dificultad creciente. Cada ejercicio indica qué secciones de UD3 integra. Al final de cada ejercicio hay una rúbrica de evaluación con los criterios que se valoran. La prueba objetiva RA3 (120 min, sin material) es el ejercicio final que cierra la unidad.

13.1 Ejercicio 1: Mini-juego "adivina el número"

Integra: secciones 2 (if), 4 (while), 9 (try-catch)

Enunciado:

Escribe un programa que genere un número aleatorio entre 1 y 100 (usando (int)(Math.random() * 100) + 1) y le pida al usuario que lo adivine. En cada intento, el programa responde "mayor", "menor" o "¡Has acertado en X intentos!". El juego termina cuando el usuario acierta o escribe "0" para rendirse.

Requisitos:

  1. Usa while (true) + break para el bucle principal.
  2. Usa try-catch con NumberFormatException para validar que el usuario escribe un número.
  3. Si el usuario escribe "0", muestra el número secreto y termina.
  4. Usa if / else if / else para comparar el intento con el número secreto.
  5. Cuenta los intentos con un acumulador.
  6. Usa constantes (final int) para el mínimo (1) y máximo (100).

Ejemplo de ejecución:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
He pensado un número entre 1 y 100. ¡Adivínalo! (0 para rendirte)
Intento 1: 50
El número es mayor.
Intento 2: 75
El número es menor.
Intento 3: 63
El número es mayor.
Intento 4: 70
El número es menor.
Intento 5: 67
¡Has acertado en 5 intentos!

Entrega: archivo AdivinaNumero.java en el paquete jams.programacion.ud3.

Rúbrica:

Criterio Descripción Puntos
CE 3.2 Bucle while correcto con break 2
CE 3.1 if / else if / else correcto 2
CE 3.4 try-catch con NumberFormatException 2
CE 3.5 Programa ejecutable y funcional 2
CE 3.7 Código comentado y legible 2

13.2 Ejercicio 2: Calculadora robusta con menú y excepciones

Integra: secciones 2 (if), 3 (switch), 4 (do-while), 8 (break, continue), 9 (try-catch)

Enunciado:

Escribe una calculadora con un menú interactivo que se repite hasta que el usuario elija "salir". El menú ofrece: sumar, restar, multiplicar y dividir. En cada operación, pide dos operandos (pueden ser decimales). Si el usuario escribe algo que no es un número, el programa muestra un error y vuelve a pedir el dato (no se cae).

Requisitos:

  1. Usa do-while para el menú principal (se muestra al menos una vez).
  2. Usa switch expression para ejecutar la operación elegida.
  3. Usa while + try-catch con NumberFormatException para pedir los operandos de forma robusta (volver a pedir si no es un número).
  4. Controla la división por cero con un if (b == 0).
  5. Usa continue si el usuario elige una opción no válida (vuelve al menú sin pedir operandos).
  6. Usa break cuando el usuario elija "salir".
  7. Usa IO.readln() y replace(',', '.') para aceptar decimales con coma o punto.
  8. Define constantes (final int) para las opciones del menú.

Ejemplo de ejecución:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
=== Calculadora ===
1. Sumar
2. Restar
3. Multiplicar
4. Dividir
5. Salir
Elige opción: 1
Operando A: 3,5
Operando B: abc
Error: no es un número válido. Intenta de nuevo.
Operando B: 2,5
A + B = 6.00
( vuelve a mostrar el menú )
Elige opción: 5
Adiós.

Entrega: archivo CalculadoraRobusta.java en el paquete jams.programacion.ud3.

Rúbrica:

Criterio Descripción Puntos
CE 3.2 Bucle do-while para el menú 2
CE 3.1 switch expression correcto 2
CE 3.4 try-catch robusto para operandos 2
CE 3.3 break y continue usados correctamente 1
CE 3.5 Programa ejecutable y funcional 2
CE 3.7 Código comentado y legible 1

13.3 Ejercicio 3: Sistema de validación de formulario

Integra: secciones 2 (if), 4 (while), 9 (try-catch)

Enunciado:

Escribe un programa que pida al usuario los siguientes datos y los valide uno a uno (volviendo a pedir si son incorrectos):

Campo Validación
Nombre No vacío, máximo 50 caracteres.
Edad Entero entre 0 y 120.
Email Debe contener "@".
Altura (metros) Decimal entre 0.5 y 2.5.

Al final, muestra todos los datos introducidos en un resumen formateado.

Requisitos:

  1. Usa while + try-catch para validar la edad y la altura (pueden fallar con NumberFormatException).
  2. Usa if con .isEmpty(), .length(), .contains("@") para validar nombre y email.
  3. Define constantes (final) para todos los límites (longitud máxima, edad mínima/máxima, altura mínima/máxima).
  4. Cada campo se pide en un bucle separado: no avanza hasta que sea válido.
  5. Muestra el resumen final con String.format para los decimales.

Ejemplo de ejecución:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
Nombre: Ana
Edad: 25
Email: ana@example.com
Altura (m): 1,65

=== Resumen ===
Nombre: Ana
Edad: 25 años
Email: ana@example.com
Altura: 1.65 m

Entrega: archivo ValidacionFormulario.java en el paquete jams.programacion.ud3.

Rúbrica:

Criterio Descripción Puntos
CE 3.2 Bucles while para validar cada campo 2
CE 3.1 if con validaciones de rango y contenido 2
CE 3.4 try-catch para edad y altura 2
CE 3.5 Programa ejecutable y funcional 2
CE 3.7 Código comentado y constantes bien nombradas 2

13.4 Ejercicio 4: Operaciones sobre arrays

Integra: secciones 5 (arrays), 6 (for clásico, Arrays), 7 (for-each), 10 (depuración)

Enunciado:

Dado un array de 10 enteros introducidos por el usuario, realiza las siguientes operaciones:

  1. Pedir los 10 números al usuario y guardarlos en un array (con while + try-catch para validar entrada).
  2. Mostrar el array con Arrays.toString.
  3. Sumar todos los elementos con for-each.
  4. Calcular el máximo y el mínimo con for clásico.
  5. Buscar un número (pedido al usuario) con for clásico y break al encontrarlo.
  6. Ordenar el array con Arrays.sort y mostrarlo con Arrays.toString.
  7. Buscar un número en el array ordenado con Arrays.binarySearch.

Requisitos:

  1. Importa java.util.Arrays.
  2. Usa for-each para sumar (no for clásico).
  3. Usa for clásico para buscar (necesitas el índice para break).
  4. Define constantes para el tamaño del array.
  5. Depura el programa con IntelliJ: pon un breakpoint en la línea de la suma y verifica que el acumulador cambia correctamente en cada iteración.

Ejemplo de ejecución:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
Introduce 10 números enteros:
Número 1: 23
Número 2: 7
...
Número 10: 15

Array original: [23, 7, 45, 12, 89, 34, 56, 1, 67, 15]
Suma: 349
Máximo: 89
Mínimo: 1
¿Qué número buscas? 34
Encontrado en la posición 5 (antes de ordenar)
Array ordenado: [1, 7, 12, 15, 23, 34, 45, 56, 67, 89]
¿Qué número buscas en el array ordenado? 34
Encontrado en la posición 5 (búsqueda binaria)

Entrega: archivo OperacionesArrays.java en el paquete jams.programacion.ud3.

Rúbrica:

Criterio Descripción Puntos
CE 3.5 Arrays: declaración, recorrido, modificación 2
CE 3.2 for-each para suma, for clásico para búsqueda 2
CE 3.3 break al encontrar el elemento 1
CE 3.4 try-catch para validar entrada 2
CE 3.6 Depuración con breakpoint en la suma 2
CE 3.7 Código comentado 1

13.5 Ejercicio 5: Recorrido de matrices

Integra: secciones 5 (arrays), 6 (for clásico), 7 (for-each), 8 (bucles anidados, matrices int[][])

Enunciado:

Dada una matriz int[][] de 4 filas × 5 columnas con valores introducidos en el código, realiza:

  1. Mostrar la matriz con dos for anidados (formato tabla con \t).
  2. Sumar todos los elementos con for-each anidado (externo + interno).
  3. Calcular la suma de cada fila y mostrarla.
  4. Buscar un elemento (pedido al usuario) en la matriz y mostrar su posición (fila, columna) o "No está". Usa break etiquetado para salir de los dos bucles.
  5. Calcular el máximo de toda la matriz.

Requisitos:

  1. La matriz se define con valores literales en el código (no se pide al usuario).
  2. Para mostrar la matriz: for clásico externo (filas) + for clásico interno (columnas).
  3. Para sumar todos: for-each externo (cada fila es int[]) + for-each interno (cada valor).
  4. Para buscar: for clásico externo + for clásico interno + break etiquetado.
  5. Para el máximo: for-each anidado, inicializando con matriz[0][0].

Ejemplo de ejecución:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
=== Matriz ===
3  7  2  9  4
6  1  8  5  2
9  4  3  7  1
2  8  6  4  5

Suma total: 88
Suma fila 0: 25
Suma fila 1: 22
Suma fila 2: 24
Suma fila 3: 25

¿Qué número buscas? 8
Encontrado en (fila 1, columna 2)
Máximo de la matriz: 9

Entrega: archivo RecorridoMatrices.java en el paquete jams.programacion.ud3.

Rúbrica:

Criterio Descripción Puntos
CE 3.5 Matrices int[][]: declaración y acceso 2
CE 3.2 Bucles anidados (for clásico y for-each) 2
CE 3.3 break etiquetado para búsqueda 2
CE 3.7 Código comentado 2
CE 3.6 Depuración: verificar suma con breakpoint 2

13.6 Ejercicio 6: Gestor de notas con aserciones

Integra: secciones 5 (arrays), 6 (for clásico, Arrays), 7 (for-each), 9 (try-catch), 11 (assert)

Enunciado:

Escribe un programa que gestione las notas de 5 alumnos:

  1. Pide las 5 notas al usuario (decimales entre 0 y 10) con while + try-catch para validar entrada.
  2. Almacena las notas en un array double[].
  3. Calcula la media, el máximo y el mínimo con for-each.
  4. Ordena las notas con Arrays.sort.
  5. Muestra las notas ordenadas con Arrays.toString.
  6. Cuenta cuántos alumnos han aprobado (nota >= 5) y cuántos han suspendido.
  7. Aserciones: incluye las siguientes:
  8. Precondición: el array no es null y tiene al menos 1 elemento.
  9. Postcondición: la media está entre 0 y 10.
  10. Postcondición: el máximo está entre 0 y 10.
  11. Activa -ea en VM options para que las aserciones funcionen.

Requisitos:

  1. Usa try-catch con NumberFormatException para validar que la entrada es numérica.
  2. Usa if para validar el rango [0, 10] de cada nota.
  3. Usa for-each para calcular media, máximo y mínimo (tres bucles separados).
  4. Usa assert con mensaje en las tres aserciones.
  5. Define constantes (final int NUM_ALUMNOS = 5, final double NOTA_MIN = 0.0, final double NOTA_MAX = 10.0, final double NOTA_APROBADO = 5.0).

Ejemplo de ejecución:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
Introduce las notas de 5 alumnos:
Nota 1: 7,5
Nota 2: 4,0
Nota 3: 8,5
Nota 4: 6,0
Nota 5: 3,5

Notas ordenadas: [3.5, 4.0, 6.0, 7.5, 8.5]
Media: 5.90
Máximo: 8.50
Mínimo: 3.50
Aprobados: 3
Suspensos: 2

Entrega: archivo GestorNotas.java en el paquete jams.programacion.ud3.

Rúbrica:

Criterio Descripción Puntos
CE 3.5 Array double[]: declaración, recorrido 2
CE 3.2 for-each para media, máximo, mínimo 2
CE 3.4 try-catch para validar entrada 2
CE 3.9 assert de precondición y postcondición 2
CE 3.7 Código comentado y constantes 2

13.7 Prueba objetiva RA3

Duración: 120 minutos.

Material permitido: Ninguno (sin apuntes, sin internet, sin IntelliJ).

Formato:

La prueba objetiva RA3 consta de dos partes:

Parte A: Preguntas teóricas (30% de la nota)

  • 10 preguntas tipo test (similar al test de la sección 12).
  • 5 preguntas de respuesta breve (definir conceptos, explicar diferencias).
  • Cubre todas las secciones 1-11 de UD3.

Parte B: Ejercicio práctico (70% de la nota)

Un ejercicio de programación en papel que integra:

  • Selección (if / else if / else y/o switch).
  • Iteración (while, do-while, for o for-each).
  • Arrays (declaración, recorrido, acceso por índice).
  • Excepciones (try-catch con NumberFormatException para validar entrada).
  • Sentencias de salto (break o continue).

El alumno debe escribir el código completo en papel, sin ayuda del IDE. Se valora:

Criterio Descripción Puntos
CE 3.1 Estructuras de selección correctas 15
CE 3.2 Estructuras de repetición correctas 15
CE 3.3 Sentencias de salto correctas 10
CE 3.4 Control de excepciones con try-catch 15
CE 3.5 Programa ejecutable y funcional 10
CE 3.6 Prueba y depuración (identificar bugs en código dado) 10
CE 3.7 Código comentado y legible 10
CE 3.8 Creación de excepciones (identificar cuándo es apropiado) 5
CE 3.9 Aserciones (identificar precondiciones y postcondiciones) 10

Para aprobar la prueba objetiva: la nota media de todos los criterios debe ser igual o superior a 5. Si algún criterio tiene menos de 4,5, no se hace media.

13.8 Resumen de ejercicios

Ejercicio Integra Dificultad Entrega
1. Adivina el número S2, S4, S9 Baja AdivinaNumero.java
2. Calculadora robusta S2, S3, S4, S8, S9 Media CalculadoraRobusta.java
3. Validación de formulario S2, S4, S9 Media ValidacionFormulario.java
4. Operaciones sobre arrays S5, S6, S7, S10 Media-Alta OperacionesArrays.java
5. Recorrido de matrices S5, S6, S7, S8 Alta RecorridoMatrices.java
6. Gestor de notas con aserciones S5, S6, S7, S9, S11 Alta GestorNotas.java
Prueba objetiva RA3 Todo UD3 Examen En aula (120 min)

13.9 Cierre de la unidad

Con esta sección termina la Unidad Didáctica 3 — Control de Flujo y Depuración. Has aprendido:

  1. Conceptos de control de flujo y diagramas (sección 1).
  2. Selección con if / else if / else y switch expression (secciones 2-3).
  3. Iteración con while, do-while, for clásico y for-each (secciones 4, 6, 7).
  4. Arrays unidimensionales y matrices bidimensionales (secciones 5, 8).
  5. Bucles anidados y sentencias de salto break, continue, return (sección 8).
  6. Manejo de excepciones con try-catch-finally y try-with-resources (sección 9).
  7. Depuración con IntelliJ IDEA: breakpoints, Step Over/Into/Out, Evaluate Expression (sección 10).
  8. Aserciones con assert: precondiciones, postcondiciones e invariantes de bucle (sección 11).
  9. Test de repaso global (sección 12).
  10. Ejercicios integradores que combinan todo lo anterior (esta sección).

Lo que viene después de UD3

UD3 se completa en la segunda evaluación (las primeras secciones se ven en la primera evaluación). Después de UD3, el siguiente bloque es:

  • UD2 — POO con la API de Java (RA2): aprenderás qué son las clases y los objetos, y usarás las clases predefinidas del API de Java (String en profundidad, Math, Random, java.time, StringBuilder, wrappers, Objects). También verás String.matches con expresiones regulares, que en UD3 no usamos.
  • UD4 — Clases y Objetos Propios (RA4): crearás tus propias clases, con encapsulación, constructores, herencia, records, enums y sealed classes. Aquí también crearás tus propias excepciones (class MiExcepcion extends Exception), que en UD3 no pudimos ver porque necesitabas POO.

Lo que no se vio en UD3 y se verá después

Concepto Dónde se ve
String.matches con regex UD2 (métodos de String) y UD6 (java.util.regex).
Pattern matching con instanceof UD7 (POO Avanzada).
Switch con pattern matching y guards UD7 (POO Avanzada).
Excepciones propias (class ... extends Exception) UD4 (sección 10).
Colecciones (List, Set, Map) UD6.
for-each sobre colecciones UD6.
StringBuilder para concatenación eficiente UD2.
Scanner UD2 (mencionado, pero IO.readln() es la API principal).
JUnit (testing) UD2 (intro), UD4 (profundización).
IOException con ficheros UD5.
SQLException con JDBC UD9.
Logging (SLF4J, Logback) UD5 / profesional.

Cierre del profesor. Has llegado al final de UD3. Es la unidad más grande y más importante del módulo de Programación: todo lo que viene después (POO, colecciones, ficheros, bases de datos, JavaFX) se basa en lo que has aprendido aquí. Si dominas las estructuras de control (selección, iteración, salto), los arrays, las excepciones y la depuración, tienes el 70 % del camino andado para ser un programador Java profesional. El otro 30 % es POO (que verás en UD2 y UD4) y las APIs específicas (colecciones, ficheros, bases de datos). La regla más importante que te llevas de toda la unidad es: < no <= con length, for-each lee, for clásico escribe, assert para bugs del programador, try-catch para errores del usuario, y Step Over (F8) por defecto en el depurador. Si interiorizas esas cuatro reglas, vas a programar mejor que el 80 % de los que empiezan. Nos vemos en UD2, donde descubrirás qué hay detrás de String, Math, Random y todas esas clases que has estado usando sin saber cómo funcionaban por dentro.