Tema 20 · Excepciones y propagación

21 de noviembre de 2026⏱ 5 min de lecturaProf. profesor

Al terminar podrás:

  1. Entender qué es una excepción y cómo viaja por la pila de llamadas
  2. Manejar errores con try, catch y finally
  3. Lanzar excepciones y crear excepciones propias

CONCEPTO

¿Qué es una excepción?

Es un evento anormal que ocurre en tiempo de ejecución e interrumpe el flujo normal del programa.

Se lanza

Java crea un objeto con la información del error (tipo, mensaje, línea) y lo «lanza».

Se propaga

El objeto sube por la pila de llamadas buscando un bloque que lo maneje.

Se captura

Si nadie lo captura, la JVM detiene el programa y muestra el stack trace.

JERARQUÍA

Todas heredan de Throwable

Throwable

raíz de la jerarquía

Error

fallas graves de la JVM

Exception

situaciones que el programa puede manejar

  • OutOfMemoryError
  • StackOverflowError

No se capturan: se corrige la causa.

RuntimeException

UNCHECKED

NullPointerException, ArithmeticException, NumberFormatException…

IOException…

CHECKED

SQLException, FileNotFoundException y las demás que no heredan de RuntimeException

TIPOS

Checked vs. unchecked

AspectoCheckedUnchecked
Heredan deException (no de RuntimeException)RuntimeException
¿Obligatorio manejarlas?Sí: try-catch o throwsNo
RepresentanProblemas externos: archivos, redErrores de programación o datos inválidos
EjemplosIOException, SQLExceptionNullPointerException, IllegalArgumentException

Regla práctica: si quien llama puede recuperarse, checked; si es un error de programación, unchecked.

SINTAXIS

try · catch · finally

Scanner sc = new Scanner(System.in);
try {
    System.out.print("Divisor: ");
    int divisor = sc.nextInt();
    System.out.println(100 / divisor);
} catch (ArithmeticException e) {
    System.out.println("No se divide para 0");
} catch (InputMismatchException e) {
    System.out.println("Debe ser un entero");
} finally {
    System.out.println("Fin del cálculo");
}

try

Código que puede fallar; si una línea falla, el resto del bloque se salta.

catch

Se evalúan en orden: entra al primero que coincide. De lo específico a lo general.

finally

Se ejecuta siempre, haya o no excepción.

PROPAGACIÓN

La excepción sube por la pila

public class Propagacion {
    static int dividir(int a, int b) {
        return a / b;                    // 3. aquí ocurre
    }

    static int calcular(int x) {
        return dividir(100, x);          // 2. no la maneja: sube
    }

    public static void main(String[] args) {
        try {
            calcular(0);                 // 1. llamada inicial
        } catch (ArithmeticException e) {
            System.out.println("Capturada en main: " + e.getMessage());
        }
        System.out.println("El programa continúa");
    }
}

PROPAGACIÓN

La pila de llamadas

dividir(100, 0)

ocurre ArithmeticException

calcular(0)

no tiene catch: la deja pasar

main

catch (ArithmeticException e): la maneja

Consola

Capturada en main: / by zero
El programa continúa

Cada método que no la captura termina en ese momento. Si main tampoco la capturara, el programa se detendría con el stack trace.

LANZAR

throw y throws

throw: lanza una excepción

public void setEdad(int edad) {
    if (edad < 0 || edad > 120) {
        throw new IllegalArgumentException(
            "Edad inválida: " + edad);
    }
    this.edad = edad;
}

throws: avisa que puede lanzarla

public String leer(String ruta)
        throws IOException {
    return Files.readString(Path.of(ruta));
}

Quien llame a leer() debe capturar IOException o declarar también throws: así se propaga una checked.

EXCEPCIONES PROPIAS

Crea las tuyas con herencia

public class NotaInvalidaException extends Exception {
    public NotaInvalidaException(String msg) {
        super(msg);
    }
    public NotaInvalidaException(String msg, Throwable causa) {
        super(msg, causa);
    }
}

if (nota < 0 || nota > 10) {
    throw new NotaInvalidaException("Nota fuera de rango: " + nota);
}

extends Exception

Será checked.

extends RuntimeException

Será unchecked.

Causa

El segundo constructor encadena la excepción original.

EJERCICIO GUIADO

Cuenta bancaria con validaciones

Modela una cuenta que rechace operaciones inválidas usando excepciones.

  • Crea la excepción checked SaldoInsuficienteException, que informe cuánto falta.
  • Crea CuentaBancaria con titular, saldo y retirar().
  • Si el monto es menor o igual a 0, lanza IllegalArgumentException.
  • Si el retiro supera el saldo, lanza SaldoInsuficienteException.
  • En main, procesa varios retiros con try-catch-finally y muestra el saldo después de cada uno.

SOLUCIÓN · 1 DE 3

La excepción propia

public class SaldoInsuficienteException extends Exception {
    private final double faltante;

    public SaldoInsuficienteException(double faltante) {
        super(String.format("Saldo insuficiente. Faltan $%.2f", faltante));
        this.faltante = faltante;
    }

    public double getFaltante() {
        return faltante;
    }
}

Además del mensaje, guarda cuánto falta: el programa puede usar getFaltante().

SOLUCIÓN · 2 DE 3

CuentaBancaria (extracto)

public class CuentaBancaria {
    private double saldo;

    public void retirar(double monto) throws SaldoInsuficienteException {
        validarMonto(monto);
        if (monto > saldo) {
            throw new SaldoInsuficienteException(monto - saldo);
        }
        saldo -= monto;
    }

    private void validarMonto(double monto) {
        if (monto <= 0) {
            throw new IllegalArgumentException("El monto debe ser mayor que 0");
        }
    }
}

SOLUCIÓN · 3 DE 3

Manejo en main

CuentaBancaria cuenta = new CuentaBancaria("Ana", 100);
double[] retiros = {30, -5, 200, 50};
for (double monto : retiros) {
    try {
        cuenta.retirar(monto);
        System.out.printf("Retiro de %.2f OK%n", monto);
    } catch (SaldoInsuficienteException e) {
        System.out.println("Rechazado: " + e.getMessage());
    } catch (IllegalArgumentException e) {
        System.out.println("Error: " + e.getMessage());
    } finally {
        System.out.printf("Saldo: %.2f%n", cuenta.getSaldo());
    }
}

RESULTADO

Salida del programa

Consola

Retiro de 30.00 OK
Saldo: 70.00
Error: El monto debe ser mayor que 0
Saldo: 70.00
Rechazado: Saldo insuficiente. Faltan $130.00
Saldo: 70.00
Retiro de 50.00 OK
Saldo: 20.00

En ningún caso el programa se detiene: 100 − 30 − 50 = 20.

DEBER

Inventario de una tienda

Un programa que nunca termine por un error de datos.

  • Producto (código, nombre, precio, stock) e Inventario con un ArrayList.
  • StockInsuficienteException y ProductoNoEncontradoException (checked) con el código en el mensaje.
  • vender(codigo, cantidad): IllegalArgumentException si la cantidad es ≤ 0; deja que buscar() propague su excepción.
  • Menú con Scanner: captura InputMismatchException y vuelve a pedir el dato.

Entrega: proyecto en .zip + capturas de ejecución · Fecha: [definir] · Criterios de evaluación: ver la página del curso