Manejo Estructurado de Excepciones en Java

1. Introducción a las excepciones

En cualquier sistema de software, pueden ocurrir situaciones inesperadas durante la ejecución del programa. Estas situaciones se conocen como excepciones.

Una excepción es un evento que interrumpe el flujo normal de ejecución de un programa. Cuando un programa se ejecuta, sigue un flujo secuencial de instrucciones. Este flujo solo se mantiene mientras todas las operaciones sean válidas. Sin embargo, cuando ocurre una operación inválida (por ejemplo, dividir entre cero o acceder a memoria inexistente), el flujo no puede continuar de forma normal.

En lugar de detener el programa sin explicación, Java utiliza un mecanismo estructurado donde:

Se crea un objeto excepción
Se lanza ese objeto
Se busca un manejador adecuado

Esto convierte los errores en elementos controlables dentro del programa, lo cual es una gran ventaja frente a lenguajes más antiguos.

🔹 Ejemplo sin manejo de excepciones

public class Ejemplo1 {

    public static void main(String[] args) {

        int a = 10;
        int b = 0;

        int resultado = a / b; // Error: división entre cero
        System.out.println("Resultado: " + resultado);
    }
}

❌ Resultado:

Exception in thread "main" java.lang.ArithmeticException: / by zero

🔎 Análisis

El programa se detiene abruptamente porque no hay un mecanismo que capture la excepción.
Java detecta la operación inválida y genera automáticamente un objeto ArithmeticException.
Al no existir un bloque catch, la excepción se propaga hasta el método main, lo que provoca la finalización del programa.

Esto evidencia la importancia de manejar errores para evitar fallos inesperados en sistemas reales.

2. Jerarquía de excepciones en Java

En Java, todas las excepciones derivan de la clase base:

Throwable

Se divide en dos grandes ramas:

Error → Problemas graves del sistema (no se manejan normalmente)
Exception → Problemas que el programa puede manejar

La jerarquía de excepciones en Java está basada en herencia, uno de los pilares de la POO. Esto permite que las excepciones compartan comportamiento común y que puedan ser tratadas de forma general o específica.

Por ejemplo:

Capturar Exception permite manejar muchas excepciones a la vez
Capturar una subclase permite un manejo más preciso

🔎 Profundización en la división

✔ Error

Representa fallos graves como:

Falta de memoria (OutOfMemoryError)
Desbordamiento de pila (StackOverflowError)

👉 Estos errores no suelen manejarse porque indican problemas del sistema, no del programa.

✔ Exception

Aquí es donde el desarrollador trabaja activamente.

Dentro de Exception existe una subdivisión fundamental:

Exception

 ├── Checked Exceptions

 └── RuntimeException (Unchecked Exceptions)

2.1 Jerarquía de excepciones detallada

java.lang.Object

    └── java.lang.Throwable

            ├── java.lang.Error (Unchecked)

            │       ├── OutOfMemoryError

            │       ├── StackOverflowError

            │       └── NoClassDefFoundError

            │

            └── java.lang.Exception

                    ├── Checked Exceptions

                    │       ├── IOException

                    │       ├── SQLException

                    │       ├── ClassNotFoundException

                    │       └── InterruptedException

                    │

                    └── java.lang.RuntimeException (Unchecked)

                            ├── NullPointerException

                            ├── IllegalArgumentException

                            ├── ArrayIndexOutOfBoundsException

                            ├── ArithmeticException

                            └── ClassCastException

Tipos de excepciones

✔ Checked (verificadas)

El compilador obliga a manejarlas.

Las checked exceptions representan situaciones externas al programa que pueden fallar incluso si el código es correcto, como:

Archivos inexistentes
Problemas de red
Fallos de base de datos

Java obliga a manejarlas porque estas situaciones no pueden garantizarse en tiempo de compilación.

✔ Ejemplo

import java.io.*;

public class EjemploChecked {

    public static void main(String[] args) throws IOException {
        FileReader file = new FileReader("archivo.txt");
    }
}

✔ Unchecked (no verificadas)

Ocurren en tiempo de ejecución.

Las unchecked exceptions (subclases de RuntimeException) suelen ser resultado de errores en la lógica del programa, por ejemplo:

Dividir entre cero
Acceder a un índice inválido
Usar objetos nulos

👉 No son obligatorias porque el problema no es externo, sino del diseño del código.

✔ Ejemplo

int x = 10 / 0; // ArithmeticException

3. Manejo básico de excepciones

Para manejar excepciones se utilizan los bloques:

try
catch
finally

El manejo de excepciones introduce un flujo alternativo de ejecución. Cuando ocurre una excepción dentro del try, el flujo normal se interrumpe y se redirige al bloque catch.

Esto permite:

Evitar que el programa termine abruptamente
Definir respuestas controladas ante errores
Mantener la estabilidad del sistema

🔹 Ejemplo básico

public class EjemploTryCatch {

    public static void main(String[] args) {

        try {
            int a = 10;
            int b = 0;
            int resultado = a / b;
        } catch (ArithmeticException e) {
            System.out.println("Error: no se puede dividir entre cero.");
        }
    }
}

✔ Explicación ampliada

try: delimita el código donde puede ocurrir un error.
catch: captura una excepción específica, e es un objeto que contiene:

tipo de error
mensaje
stack trace

🔹 Múltiples catch

try {
    int[] numeros = new int[5];
    numeros[10] = 50;
} catch (ArithmeticException e) {
    System.out.println("Error aritmético");
} catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("Índice fuera de rango");
}

🔹 Uso de finally

try {
    System.out.println("Ejecutando...");
} catch (Exception e) {
    System.out.println("Error");
} finally {
    System.out.println("Este bloque siempre se ejecuta");
}

4. Lanzamiento de excepciones (throw y throws)

🔹 throw

if (edad < 0) {
    throw new IllegalArgumentException("La edad no puede ser negativa");
}

🔹 throws

public static void leerArchivo() throws IOException {
    FileReader file = new FileReader("archivo.txt");
}

🔎 Diferencia clave

throw	throws
Lanza una excepción	Declara una posible excepción
Ocurre en ejecución	Ocurre en la firma del método
Control inmediato	Propagación del error

5. Creación de excepciones personalizadas

Las excepciones personalizadas permiten representar errores específicos del dominio del problema.

Esto es importante porque:

mejora la claridad del código
permite diferenciar tipos de errores
facilita el mantenimiento


public class SaldoInsuficienteException extends Exception {

    public SaldoInsuficienteException(String mensaje) {
        super(mensaje);
    }
}

Uso:

public void retirar(double monto) throws SaldoInsuficienteException {

    if (monto > saldo) {
        throw new SaldoInsuficienteException("Saldo insuficiente");
    }
}

✔ Concepto POO aplicado:

Encapsulación
Reutilización
Abstracción

6. Buenas prácticas

❌ Incorrecto:

catch (Exception e) {
}

✔ Correcto:

catch (ArithmeticException e) {
    System.out.println("Error: " + e.getMessage());
}

7. Manejo de recursos (try-with-resources)

try (FileReader file = new FileReader("archivo.txt")) {
    System.out.println("Archivo abierto correctamente");
} catch (IOException e) {
    System.out.println("Error al abrir archivo");
}

8. Depuración y análisis de errores

e.printStackTrace();

9. Integración del manejo de excepciones con POO

En la Programación Orientada a Objetos, las excepciones no solo sirven para evitar fallos, sino para:

Modelar errores como objetos
Separar responsabilidades
Controlar el flujo entre componentes
Mantener desacoplamiento

🔹 9.2 Modelo simple

Antes de hablar de arquitectura por capas, es fundamental entender cómo funcionan las excepciones dentro de un diseño básico orientado a objetos.

🔎 Escenario

Una clase CuentaBancaria con una regla:

No se puede retirar más dinero del saldo disponible

Excepción personalizada

public class SaldoInsuficienteException extends Exception {
    public SaldoInsuficienteException(String mensaje) {
        super(mensaje);
    }
}

🔎 Explicación conceptual

Aquí estamos:

Creando un nuevo tipo de error

Representando una regla del dominio (negocio)
Aplicando herencia (POO)

Clase de dominio o modelo

public class CuentaBancaria {

    private double saldo;

    public CuentaBancaria(double saldoInicial) {
        this.saldo = saldoInicial;
    }

    public void retirar(double monto) throws SaldoInsuficienteException {

        if (monto > saldo) {
            throw new SaldoInsuficienteException("Saldo insuficiente");
        }

        saldo -= monto;
    }
}

🔎 Explicación profunda

Este método hace tres cosas importantes:

Valida una regla del negocio

Lanza una excepción si se viola

Declara (throws) que puede fallar

👉 Esto es clave en POO: la clase protege su propio estado (encapsulación).

Uso

public class Main {

    public static void main(String[] args) {

        CuentaBancaria cuenta = new CuentaBancaria(100);

        try {
            cuenta.retirar(200);
        } catch (SaldoInsuficienteException e) {
            System.out.println(e.getMessage());
        }
    }
}

🔎 Flujo completo

Main llama a retirar()
CuentaBancaria detecta error
Lanza excepción (throw)
Main la captura (catch)
Se maneja el error

💡 Concepto clave

La clase que detecta el error no necesariamente lo maneja, solo lo reporta mediante una excepción.

🔷 9.4 Integración con modelo MVC

El enfoque simple anterior funciona, pero en sistemas grandes:

hay múltiples clases
hay acceso a base de datos
hay lógica de negocio compleja
hay interfaces de usuario

👉 Por eso se utiliza arquitectura por capas (MVC o similar)

Flujo:

Vista → Controlador → Servicio → DAO → BD

Las excepciones viajan entre capas, y cada capa decide:

si manejarla
si transformarla
o si propagarla

✔ DAO (Data Access Object)

Interactúa con la base de datos
Lanza excepciones técnicas

👉 Ejemplo: SQLException

✔ Servicio (Service)

Contiene lógica de negocio
Traduce errores técnicos a errores del dominio

✔ Controlador / Vista

Interactúa con el usuario

Muestra mensajes amigables

Ejemplo completo paso a paso

🔹 DAO

import java.sql.SQLException;public void inscribir(String alumno) throws SQLException {
    throw new SQLException("Error de conexión a BD");
}

🔎 Explicación

Se lanza una excepción técnica
No se maneja aquí
Se delega hacia arriba

🔹 Excepción de negocio (excepcion personalizada)

public class InscripcionException extends Exception {
    public InscripcionException(String mensaje) {
        super(mensaje);
    }
}

🔹 Service

try {
    dao.inscribir(alumno);
} catch (SQLException e) {
    throw new InscripcionException("No se pudo completar la inscripción");
}

🔎 Explicación

Aquí ocurre algo FUNDAMENTAL:

👉 Traducción de excepciones

Error técnico (SQLException)
Se convierte en error de negocio (InscripcionException)

🔹 Vista

try {
    service.procesarInscripcion("Juan");
} catch (InscripcionException e) {
    System.out.println(e.getMessage());
}

🔎 Flujo completo del sistema

Vista llama al servicio
Servicio llama al DAO
DAO lanza SQLException
Servicio la captura y transforma
Lanza InscripcionException
Vista la captura
Muestra mensaje al usuario

🔎 Beneficios

Desacoplamiento
Seguridad
Mantenibilidad
Reutilización

🎯 CONCLUSIÓN

El manejo de excepciones en POO:

Permite que los errores viajen entre objetos
Define responsabilidades claras
Facilita arquitecturas limpias (MVC)
Mejora la calidad del software

💡 IDEA CLAVE FINAL

En sistemas bien diseñados, las excepciones no solo se capturan:

👉 se transforman, se propagan y se interpretan según la capa.