UD2— Control de Flujo y Depuración

Escribe y depura código, analizando y utilizando las estructuras de control del lenguaje.

Aspecto	Valor
Resultado de aprendizaje	RA3 — Escribe y depura código, analizando y utilizando las estructuras de control del lenguaje.
Evaluación	1.ª evaluación
Horas	30 h (IES) + 2 h (empresa)
Peso en el módulo	7,1 %
Tecnología base	Java 25 LTS (OpenJDK Temurin 25)
IDE	IntelliJ IDEA Community Edition
Marco normativo	RD 405/2023 · RD 450/2010 · RD 659/2023

¿De qué va esta unidad?

Esta unidad es el salto más importante que das como programador. En la UD1 aprendiste a escribir programas que se ejecutan de principio a fin, línea tras línea, sin tomar decisiones. Aquí vas a aprender a que tus programas decidan, repitan e interrumpan su flujo según los datos del usuario y el estado del programa.

Sin control de flujo, un programa es poco más que una calculadora. Con control de flujo, un programa puede reaccionar al mundo, adaptarse a los datos, validar entradas, reintentar operaciones, ofrecer menús, procesar arrays y, en última instancia, comportarse como una aplicación de verdad.

Además, aprenderás a manejar errores (excepciones) y a depurar programas con IntelliJ IDEA, las dos herramientas que te acompañarán el resto del ciclo y de tu carrera profesional.

¿Qué vas a aprender?

=== "Selección"

- **`if` / `else if` / `else`**: decidir entre caminos según condiciones booleanas.
- **`switch` expression** con flecha `->`: selección por valor, con exhaustividad garantizada.
- **Operador ternario** `? :` para asignaciones condicionales.
- *Early return* y cláusulas de guarda para evitar la pirámide de la muerte.

=== "Iteración"

- **`while`** y **`do-while`**: repetir mientras se cumpla una condición.
- **`for` clásico**: repetir un número conocido de veces, recorrer arrays por índice.
- **`for-each`**: recorrer arrays sin índice, la forma más simple y segura.
- **Bucles anidados** y **matrices `int[][]`**: recorrer tablas y generar combinaciones.

=== "Arrays"

- **Arrays unidimensionales**: el tipo compuesto más básico de Java.
- Declaración, inicialización, `.length`, acceso por índice.
- `Arrays.copyOf`, `Arrays.sort`, `Arrays.binarySearch`, `Arrays.toString`.
- `String.toCharArray()` para recorrer caracteres.

=== "Excepciones"

- **`try-catch-finally`**: capturar y manejar errores en tiempo de ejecución.
- **Checked vs. unchecked**: la distinción fundamental de Java.
- **`try-with-resources`**: cierre automático de recursos `AutoCloseable`.
- `throw` y `throws`: lanzar y declarar excepciones.

=== "Depuración y aserciones"

- **Depurador de IntelliJ**: breakpoints, Step Over/Into/Out, Resume, Evaluate Expression.
- **Breakpoints condicionales** para bucles largos.
- **`assert`**: aserciones para detectar bugs del programador.
- Precondiciones, postcondiciones e invariantes de bucle.

Estructura de la unidad

Sección	Contenido	Horas
1	Control de flujo: conceptos y diagrama	~4 h
2	Selección: `if` / `else if` / `else`	~5 h
3	Selección: `switch` expression	~4 h
4	Iteración: `while` y `do-while`	~2 h
5	Arrays unidimensionales	~3 h
6	Iteración: `for` clásico sobre arrays y Strings	~2 h
7	Iteración: `for-each` (enhanced for)	~2 h
8	Bucles anidados, matrices `int[][]` y sentencias de salto	~4 h
9	Gestión de excepciones: `try-catch-finally`	~4 h
10	Depuración en IntelliJ IDEA	~3 h
11	Test de repaso	~2 h
12	Ejercicios y actividades integradoras	~4 h

Criterios de evaluación cubiertos

CE	Descripción	Secciones que lo cubren
CE 3.1	Escribe y prueba código con estructuras de selección.	S2, S3
CE 3.2	Utiliza estructuras de repetición.	S4, S6, S7, S8
CE 3.3	Reconoce las posibilidades de las sentencias de salto.	S8
CE 3.4	Escribe código utilizando control de excepciones.	S9
CE 3.5	Crea programas ejecutables combinando estructuras de control.	S2-S8, S13
CE 3.6	Prueba y depura los programas.	S10, S13
CE 3.7	Comenta y documenta el código.	Todas
CE 3.8	Crea excepciones.	UD4 (sección 10)
CE 3.9	Utiliza aserciones para la detección y corrección de errores.	S11

Lo que NO se ve en UD2 (y dónde se verá)

Concepto	¿Dónde se ve?
`String.matches` con regex	UD3 (métodos de `String`) y UD5 (`java.util.regex`).
Pattern matching con `instanceof`	UD7 (POO Avanzada).
Switch con pattern matching y guards `when`	UD7 (POO Avanzada).
Excepciones propias (`class ... extends Exception`)	UD4 (sección 10).
Colecciones (`List`, `Set`, `Map`)	UD5 (Tipos Avanzados de Datos).
`for-each` sobre colecciones (`Iterable<T>`)	UD6.
`StringBuilder` para concatenación eficiente	UD2.
`IOException` con ficheros	UD6.
`SQLException` con JDBC	UD9.
Testing con JUnit	UD2 (intro), UD4 (profundización).
Depuración avanzada (profiling, remote debug)	Fuera del módulo.

Antes de empezar

Lo que necesitas saber antes de UD2

De UD1: variables, tipos primitivos, var, String (.equals(), .length(), .charAt(), .trim(), .toLowerCase(), .isEmpty()), final para constantes, operadores (aritméticos, relacionales, lógicos, ternario), IO.readln() / IO.println(), Integer.parseInt() / Double.parseDouble(), estructura de un programa Java (main), IntelliJ IDEA (crear proyecto Maven, compilar con Shift+F10).

Prueba objetiva RA3

Aspecto	Valor
Duración	120 minutos
Material	Sin material (sin apuntes, sin internet, sin IntelliJ)
Formato	Parte A: preguntas teóricas (30%). Parte B: ejercicio práctico (70%).
Para aprobar	Nota media de todos los CE ≥ 5. Ningún CE < 4,5.

Mapa de dependencias

Use mouse to pan and zoom

flowchart LR
    UD1["UD1 — Fundamentos<br/>Variables · Tipos · Operadores"]
    UD2["**UD2 — Control de Flujo**<br/>if · switch · bucles<br/>Arrays · for-each · matrices<br/>Excepciones · Depuración · assert"]
    UD3["UD3 — POO API Java<br/>String · Math · Random<br/>java.time · StringBuilder"]
    UD4["UD4 — Clases Propias<br/>Encapsulación · Herencia<br/>Records · Enums · Sealed<br/>Excepciones propias"]

    UD1 --> UD2
    UD2 --> UD3
    UD2 --> UD4

    style UD2 fill:#e65100,color:#fff,stroke:#bf360c,stroke-width:3px
    style UD1 fill:#1565c0,color:#fff,stroke:#0d47a1
    style UD3 fill:#2e7d32,color:#fff,stroke:#1b5e20
    style UD4 fill:#6a1b9a,color:#fff,stroke:#4a148c

Bienvenido a UD2. Esta es la unidad donde dejas de escribir programas que "hacen cosas" y empiezas a escribir programas que deciden, repiten y manejan errores. Es el salto de calculadora a aplicación. Si dominas lo que verás aquí, tienes el 70 % del camino andado para ser un programador Java profesional. Vamos a ello.