Excepciones - parte 1

Jerarquía de excepciones

flowchart TB
    Throw[Throwable] --> Err[Error]
    Throw --> Exc[Exception]
    Err --> SO[StackOverflowError]
    Err --> OOM[OutOfMemoryError]
    Exc --> Run[RuntimeException unchecked]
    Exc --> Check[Checked extends Exception]
    Run --> NPE[NullPointerException]
    Run --> Iae[IllegalArgumentException]
    Check --> IO[IOException]
    Check --> Sql[SQLException]
    Throw --> TWR[try with resources]

¿Para qué sirven las excepciones?

Las excepciones permiten gestionar situaciones anómalas o errores que pueden ocurrir durante la ejecución de un programa. En lugar de permitir que un error detenga abruptamente la aplicación, las excepciones proporcionan una forma estructurada de detectar, comunicar y manejar estos problemas.

Cuando se desarrolla software, es inevitable enfrentarse a situaciones imprevistas: archivos que no existen, conexiones de red interrumpidas, divisiones por cero o intentos de acceder a posiciones inexistentes en un array.

Propósitos principales de las excepciones

• Separación de la lógica de error: Las excepciones permiten mantener el código principal limpio y enfocado en el flujo normal, mientras que la gestión de errores se maneja por separado.

// Sin excepciones (código mezclado con verificaciones de error)
public int dividir(int a, int b) {
    if (b == 0) {
        System.err.println("Error: División por cero");
        return 0; // ¿Qué valor devolver en caso de error?
    }
    return a / b;
}

// Con excepciones (código más limpio)
public int dividir(int a, int b) throws ArithmeticException {
    return a / b; // Java lanzará automáticamente ArithmeticException si b es 0
}

• Propagación de errores: Las excepciones pueden propagarse a través de múltiples niveles de llamadas a métodos, permitiendo que el error se maneje en el nivel más adecuado.

public void procesarDatos() throws IOException {
    leerArchivo("datos.txt");
    // Si leerArchivo falla, la excepción se propaga automáticamente
}

public void leerArchivo(String ruta) throws IOException {
    // Código para leer archivo que puede lanzar IOException
    Files.readAllLines(Path.of(ruta));
}

• Agrupación jerárquica de errores: Java organiza las excepciones en una jerarquía de clases, lo que permite capturar categorías enteras de errores o manejar tipos específicos según sea necesario.

try {
    // Código que podría lanzar diferentes tipos de excepciones
    procesarArchivo();
} catch (FileNotFoundException e) {
    // Manejo específico para archivo no encontrado
    System.err.println("El archivo no existe: " + e.getMessage());
} catch (IOException e) {
    // Manejo para otros errores de E/S
    System.err.println("Error de E/S: " + e.getMessage());
}

• Información detallada sobre errores: Las excepciones contienen datos sobre el error, como mensajes descriptivos, la pila de llamadas y, potencialmente, la causa raíz.

try {
    int[] numeros = new int[5];
    numeros[10] = 50; // Esto causará ArrayIndexOutOfBoundsException
} catch (ArrayIndexOutOfBoundsException e) {
    System.err.println("Mensaje: " + e.getMessage());
    System.err.println("Tipo de excepción: " + e.getClass().getName());
    e.printStackTrace(); // Muestra la pila de llamadas completa
}

Ventajas del uso de excepciones

• Robustez: Las aplicaciones que manejan adecuadamente las excepciones son más resistentes a fallos y pueden continuar funcionando incluso cuando ocurren errores.

public void procesarDocumentos() {
    List<String> documentos = obtenerListaDocumentos();
    
    for (String documento : documentos) {
        try {
            procesarDocumento(documento);
        } catch (Exception e) {
            // Registrar el error pero continuar con el siguiente documento
            System.err.println("Error al procesar " + documento + ": " + e.getMessage());
        }
    }
    
    System.out.println("Procesamiento completado");
}

• Legibilidad: El código principal se mantiene enfocado en la lógica de negocio, sin mezclarse con verificaciones de errores constantes.
• Mantenibilidad: La centralización del manejo de errores facilita los cambios en la estrategia de gestión de errores sin modificar la lógica principal.
• Recuperación: Permite implementar estrategias de recuperación ante fallos, como reintentos o soluciones alternativas.

public void conectarServidor() {
    int intentos = 0;
    boolean conectado = false;
    
    while (!conectado && intentos < 3) {
        try {
            // Intentar conexión
            abrirConexion();
            conectado = true;
            System.out.println("Conexión establecida");
        } catch (ConexionException e) {
            intentos++;
            System.out.println("Intento " + intentos + " fallido: " + e.getMessage());
            
            if (intentos < 3) {
                // Esperar antes de reintentar
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                }
            }
        }
    }
    
    if (!conectado) {
        System.err.println("No se pudo establecer conexión después de 3 intentos");
    }
}

Cuándo utilizar excepciones

Las excepciones se utilizan principalmente en situaciones excepcionales (como su nombre indica), no para controlar el flujo normal del programa. Se recomienda su uso en los siguientes casos:

• Errores de validación que no pueden ser evitados mediante verificaciones previas.
• Problemas con recursos externos como archivos, bases de datos o servicios web.
• Violaciones de precondiciones importantes para el funcionamiento correcto de un método.
• Errores de programación como índices fuera de rango o referencias nulas.

public Usuario buscarPorId(int id) throws UsuarioNoEncontradoException {
    // Buscar usuario en la base de datos
    Usuario usuario = repositorio.findById(id);
    
    if (usuario == null) {
        // Situación excepcional: el ID debería existir
        throw new UsuarioNoEncontradoException("No se encontró usuario con ID: " + id);
    }
    
    return usuario;
}

Las excepciones tienen un coste de rendimiento, por lo que no deben usarse para situaciones que forman parte del flujo normal de la aplicación. Por ejemplo, no se debe usar una excepción para detectar el final de un archivo si se está leyendo línea por línea, ya que llegar al final es un comportamiento esperado.

Tipos de excepciones: excepciones comprobadas y no comprobadas

En Java, las excepciones se dividen en dos categorías principales: excepciones comprobadas (checked exceptions) y excepciones no comprobadas (unchecked exceptions). Esta clasificación determina cómo el compilador trata cada tipo de excepción y cómo los desarrolladores deben manejarlas en su código.

La distinción entre estos dos tipos se basa en la jerarquía de clases de excepciones en Java. Todas las excepciones derivan de la clase Throwable, que tiene dos subclases directas: Error y Exception.

Jerarquía de excepciones

Throwable
├── Error                 // Errores graves del sistema (unchecked)
│   ├── OutOfMemoryError
│   ├── StackOverflowError
│   └── ...
└── Exception             // Base para todas las excepciones
    ├── IOException       // Checked exceptions
    ├── SQLException
    ├── ClassNotFoundException
    ├── ...
    └── RuntimeException  // Base para unchecked exceptions
        ├── NullPointerException
        ├── ArithmeticException
        ├── IndexOutOfBoundsException
        └── ...

Excepciones comprobadas (Checked Exceptions)

Las excepciones comprobadas son aquellas que heredan de Exception pero no de RuntimeException. Se caracterizan por:

• El compilador obliga a manejarlas explícitamente mediante bloques try-catch o a declararlas en la firma del método con throws.
• Representan condiciones recuperables que una aplicación debería anticipar y de las que podría recuperarse.
• Suelen estar relacionadas con factores externos al programa, como problemas de E/S, red o bases de datos.

public void leerArchivo(String ruta) throws IOException {
    // Si no declaramos "throws IOException", el código no compilará
    Files.readAllLines(Path.of(ruta));
}

// Alternativa: manejar la excepción con try-catch
public String leerContenidoArchivo(String ruta) {
    try {
        return Files.readString(Path.of(ruta));
    } catch (IOException e) {
        System.err.println("Error al leer el archivo: " + e.getMessage());
        return ""; // Valor por defecto en caso de error
    }
}

Ejemplos comunes de excepciones comprobadas:

• IOException: Problemas de entrada/salida
• SQLException: Errores en operaciones de bases de datos
• ClassNotFoundException: Clase no encontrada al cargar dinámicamente
• ParseException: Error al analizar una cadena con formato específico

Excepciones no comprobadas (Unchecked Exceptions)

Las excepciones no comprobadas incluyen todas las que heredan de RuntimeException y también las de tipo Error. Sus características son:

• El compilador no obliga a capturarlas o declararlas.
• Generalmente indican errores de programación que no deberían ocurrir si el código estuviera correctamente escrito.
• Suelen ser difíciles o imposibles de recuperar en tiempo de ejecución.

public int dividir(int a, int b) {
    // No es necesario declarar "throws ArithmeticException"
    return a / b; // Lanzará ArithmeticException si b es 0
}

// Aunque no es obligatorio, podemos manejarla si queremos
public int dividirSeguro(int a, int b) {
    try {
        return a / b;
    } catch (ArithmeticException e) {
        System.err.println("Error: División por cero");
        return 0; // Valor por defecto
    }
}

Ejemplos comunes de excepciones no comprobadas:

• NullPointerException: Intento de acceder a un objeto nulo
• ArithmeticException: Operaciones aritméticas inválidas como división por cero
• IndexOutOfBoundsException: Acceso a índices fuera de los límites de un array
• IllegalArgumentException: Argumentos inválidos en llamadas a métodos
• ConcurrentModificationException: Modificación de una colección mientras se itera sobre ella

Errores (Error)

Los errores son un tipo especial de excepciones no comprobadas que indican problemas graves a nivel del sistema:

• Representan situaciones catastróficas de las que normalmente no se puede recuperar la aplicación.
• No se espera que el código los capture o maneje.
• Suelen requerir la terminación del programa.

// Ejemplo que provoca StackOverflowError
public void causarStackOverflow() {
    causarStackOverflow(); // Llamada recursiva sin condición de salida
}

// Ejemplo que puede provocar OutOfMemoryError
public void consumirMemoria() {
    List<byte[]> memoria = new ArrayList<>();
    while (true) {
        memoria.add(new byte[1024 * 1024]); // Añadir 1MB continuamente
    }
}

Ejemplos comunes de errores:

• OutOfMemoryError: La JVM se queda sin memoria
• StackOverflowError: Desbordamiento de la pila de llamadas
• NoClassDefFoundError: No se encuentra la definición de una clase
• ExceptionInInitializerError: Excepción durante la inicialización estática

¿Cuándo usar cada tipo?

La elección entre crear excepciones comprobadas o no comprobadas depende del contexto:

• Usa excepciones comprobadas cuando:
  • La condición de error es recuperable
  • Quieres forzar al llamador a manejar la situación
  • El error proviene de factores externos que el código no puede controlar
  • Existe una acción alternativa razonable que el llamador podría tomar

public class ArchivoConfiguracion {
    public static Properties cargar(String ruta) throws ConfiguracionException {
        try {
            Properties props = new Properties();
            try (FileInputStream fis = new FileInputStream(ruta)) {
                props.load(fis);
            }
            return props;
        } catch (IOException e) {
            throw new ConfiguracionException("No se pudo cargar la configuración", e);
        }
    }
}

// ConfiguracionException es una excepción comprobada personalizada
public class ConfiguracionException extends Exception {
    public ConfiguracionException(String mensaje, Throwable causa) {
        super(mensaje, causa);
    }
}

• Usa excepciones no comprobadas cuando:
  • El error indica un bug en el programa
  • La recuperación es improbable o imposible
  • Forzar el manejo sería una carga innecesaria para todos los llamadores
  • El error representa una precondición violada (como argumentos inválidos)

public class CalculadoraImpuestos {
    public double calcularImpuesto(double monto, double tasa) {
        if (monto < 0 || tasa < 0 || tasa > 1) {
            throw new IllegalArgumentException(
                "Monto debe ser positivo y tasa debe estar entre 0 y 1");
        }
        return monto * tasa;
    }
}

Buenas prácticas

• No atrapar excepciones genéricas: Evita usar catch (Exception e) o catch (Throwable e) sin una buena razón, ya que puede ocultar problemas graves.

// Mal ejemplo - atrapa todo tipo de excepciones
try {
    procesarDatos();
} catch (Exception e) {
    System.out.println("Error: " + e.getMessage());
}

// Mejor enfoque - manejo específico
try {
    procesarDatos();
} catch (IOException e) {
    System.err.println("Error de E/S: " + e.getMessage());
    // Acción específica para errores de E/S
} catch (SQLException e) {
    System.err.println("Error de base de datos: " + e.getMessage());
    // Acción específica para errores de BD
}

• No ignorar excepciones: Siempre haz algo significativo cuando capturas una excepción, incluso si es solo registrarla.

// Mal ejemplo - excepción ignorada
try {
    archivo.close();
} catch (IOException e) {
    // No hacer nada es peligroso
}

// Mejor enfoque
try {
    archivo.close();
} catch (IOException e) {
    logger.warn("No se pudo cerrar el archivo correctamente", e);
    // Podría no ser crítico, pero al menos lo registramos
}

• Preservar la causa original: Al lanzar una nueva excepción, incluye la original como causa.

try {
    repositorio.guardarDatos(datos);
} catch (SQLException e) {
    // Convertimos la excepción técnica en una de dominio, pero preservamos la causa
    throw new ErrorPersistenciaException("No se pudieron guardar los datos", e);
}

• Documentar las excepciones: Usa Javadoc para documentar qué excepciones puede lanzar un método y bajo qué circunstancias.

/**
 * Transfiere fondos entre dos cuentas.
 *
 * @param origen ID de la cuenta origen
 * @param destino ID de la cuenta destino
 * @param monto Cantidad a transferir
 * @throws CuentaInexistenteException si alguna de las cuentas no existe
 * @throws SaldoInsuficienteException si la cuenta origen no tiene fondos suficientes
 * @throws MontoInvalidoException si el monto es negativo o cero
 */
public void transferir(String origen, String destino, double monto) 
    throws CuentaInexistenteException, SaldoInsuficienteException, MontoInvalidoException {
    // Implementación
}

Manejo de excepciones

Cuando ocurre una situación excepcional durante la ejecución de un programa, se necesita un mecanismo para detectar y responder adecuadamente a estos eventos. Java proporciona una estructura clara para gestionar estas situaciones mediante bloques try-catch-finally.

Estructura básica try-catch

La estructura más básica para manejar excepciones en Java se compone de un bloque try seguido de uno o más bloques catch:

try {
    // Código que podría lanzar excepciones
    int resultado = 10 / 0; // Esto lanzará ArithmeticException
} catch (ArithmeticException e) {
    // Código que se ejecuta si ocurre una ArithmeticException
    System.err.println("Error aritmético: " + e.getMessage());
}

El flujo de ejecución es el siguiente:

1. Se ejecuta el código dentro del bloque try 2. Si ocurre una excepción, la ejecución del bloque try se interrumpe inmediatamente 3. Se busca un bloque catch compatible con el tipo de excepción lanzada 4. Si se encuentra, se ejecuta ese bloque catch 5. La ejecución continúa después del último bloque catch

Captura de múltiples excepciones

Es posible manejar diferentes tipos de excepciones con múltiples bloques catch:

try {
    int[] numeros = new int[5];
    numeros[10] = 10 / 0; // Podría lanzar dos tipos de excepciones
} catch (ArithmeticException e) {
    System.err.println("Error en operación matemática: " + e.getMessage());
} catch (ArrayIndexOutOfBoundsException e) {
    System.err.println("Índice fuera de rango: " + e.getMessage());
}

Los bloques catch se evalúan en orden, por lo que es importante colocar las excepciones más específicas antes que las más generales:

try {
    // Código que podría lanzar excepciones
    procesarArchivo("datos.txt");
} catch (FileNotFoundException e) {
    // Manejo específico para archivo no encontrado
    System.err.println("No se encontró el archivo: " + e.getMessage());
} catch (IOException e) {
    // Manejo para otros errores de E/S
    System.err.println("Error de E/S: " + e.getMessage());
} catch (Exception e) {
    // Captura cualquier otra excepción no manejada anteriormente
    System.err.println("Error general: " + e.getMessage());
}

Multi-catch (desde Java 7)

Para reducir la duplicación de código, Java permite capturar múltiples tipos de excepciones en un solo bloque catch:

try {
    // Código que podría lanzar diferentes excepciones
    Object obj = obtenerObjeto();
    String texto = (String) obj;
    int valor = Integer.parseInt(texto);
} catch (ClassCastException | NumberFormatException e) {
    // Este bloque maneja ambos tipos de excepciones
    System.err.println("Error de conversión: " + e.getMessage());
}

Las excepciones unidas con el operador | deben ser disjuntas (ninguna puede ser subclase de otra).

El bloque finally

El bloque finally contiene código que se ejecuta siempre, independientemente de si ocurre una excepción o no:

FileInputStream archivo = null;
try {
    archivo = new FileInputStream("config.txt");
    // Procesar el archivo
} catch (IOException e) {
    System.err.println("Error al procesar el archivo: " + e.getMessage());
} finally {
    // Este código se ejecuta siempre
    if (archivo != null) {
        try {
            archivo.close();
        } catch (IOException e) {
            System.err.println("Error al cerrar el archivo");
        }
    }
}

El bloque finally es ideal para:

• Liberar recursos (cerrar archivos, conexiones de red, etc.)
• Realizar operaciones de limpieza
• Asegurar que ciertas operaciones se completen independientemente de las excepciones

Try-with-resources (desde Java 7)

Para simplificar el manejo de recursos que deben cerrarse, Java introdujo la estructura try-with-resources:

try (FileInputStream archivo = new FileInputStream("datos.txt");
     BufferedReader lector = new BufferedReader(new InputStreamReader(archivo))) {
    // Usar los recursos
    String linea = lector.readLine();
    System.out.println(linea);
} catch (IOException e) {
    System.err.println("Error de E/S: " + e.getMessage());
}
// Los recursos se cierran automáticamente al finalizar el bloque try

Características importantes:

• Los recursos se cierran automáticamente al finalizar el bloque try
• Los recursos se cierran en orden inverso a su declaración
• Se pueden declarar múltiples recursos separados por punto y coma
• Los recursos deben implementar la interfaz AutoCloseable

Obtención de información de la excepción

Las excepciones en Java proporcionan métodos para obtener información detallada:

try {
    int resultado = 10 / 0;
} catch (ArithmeticException e) {
    // Mensaje de error
    System.err.println("Mensaje: " + e.getMessage());
    
    // Nombre completo de la clase de excepción
    System.err.println("Tipo: " + e.getClass().getName());
    
    // Traza completa de la pila de llamadas
    e.printStackTrace();
    
    // Causa original (si esta excepción fue causada por otra)
    Throwable causa = e.getCause();
    if (causa != null) {
        System.err.println("Causada por: " + causa.getMessage());
    }
}

Excepciones encadenadas

Es común encadenar excepciones para preservar la información de la causa original mientras se proporciona un contexto más específico:

public void guardarDatos(Usuario usuario) throws PersistenciaException {
    try {
        // Intentar guardar en la base de datos
        conexion.ejecutar("INSERT INTO usuarios VALUES (...)");
    } catch (SQLException e) {
        // Convertir la excepción técnica en una de dominio
        throw new PersistenciaException("Error al guardar el usuario: " + usuario.getId(), e);
    }
}

El constructor de la excepción que recibe otra excepción como segundo parámetro establece la causa original, que se puede recuperar posteriormente con getCause().

Patrones comunes de manejo de excepciones

Patrón de reintento

Útil para operaciones que pueden fallar temporalmente, como conexiones de red:

public void conectarServidor() {
    int intentos = 0;
    boolean conectado = false;
    
    while (!conectado && intentos < 3) {
        try {
            // Intentar conexión
            socket = new Socket("servidor.ejemplo.com", 8080);
            conectado = true;
            System.out.println("Conexión establecida");
        } catch (IOException e) {
            intentos++;
            System.out.println("Intento " + intentos + " fallido: " + e.getMessage());
            
            if (intentos < 3) {
                try {
                    // Esperar antes de reintentar
                    Thread.sleep(2000);
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                }
            }
        }
    }
    
    if (!conectado) {
        System.err.println("No se pudo establecer conexión después de 3 intentos");
    }
}

Patrón de conversión de excepciones

Convierte excepciones de bajo nivel en excepciones más significativas para la capa de aplicación:

public List<Producto> buscarProductos(String categoria) throws ServicioException {
    try {
        return repositorio.findByCategoria(categoria);
    } catch (SQLException e) {
        throw new ServicioException("Error al buscar productos de categoría: " + categoria, e);
    } catch (TimeoutException e) {
        throw new ServicioException("Tiempo de espera agotado en la búsqueda", e);
    }
}

Patrón de registro y propagación

Registra información sobre la excepción pero permite que se propague hacia arriba:

public void procesarPedido(Pedido pedido) throws ProcesoPedidoException {
    try {
        validarPedido(pedido);
        calcularTotal(pedido);
        aplicarDescuentos(pedido);
        guardarPedido(pedido);
    } catch (ValidacionException e) {
        logger.error("Error de validación en pedido " + pedido.getId(), e);
        throw new ProcesoPedidoException("Pedido inválido", e);
    } catch (CalculoException e) {
        logger.error("Error en cálculos del pedido " + pedido.getId(), e);
        throw new ProcesoPedidoException("Error en cálculos", e);
    }
}

Buenas prácticas en el manejo de excepciones

• Ser específico con las excepciones: Captura tipos específicos de excepciones en lugar de usar Exception genérico.

// Enfoque incorrecto
try {
    // Código
} catch (Exception e) { // Demasiado genérico
    System.err.println("Error");
}

// Enfoque correcto
try {
    // Código
} catch (IOException e) {
    System.err.println("Error de E/S: " + e.getMessage());
} catch (SQLException e) {
    System.err.println("Error de base de datos: " + e.getMessage());
}

• No ignorar excepciones: Siempre haz algo significativo cuando capturas una excepción.

// Incorrecto
try {
    conexion.close();
} catch (SQLException e) {
    // Vacío - ¡Peligroso!
}

// Correcto
try {
    conexion.close();
} catch (SQLException e) {
    logger.warn("No se pudo cerrar la conexión correctamente", e);
}

• Usar try-with-resources para recursos que deben cerrarse.

// Antiguo enfoque (propenso a errores)
InputStream entrada = null;
try {
    entrada = new FileInputStream("archivo.txt");
    // Usar entrada
} catch (IOException e) {
    // Manejar excepción
} finally {
    if (entrada != null) {
        try {
            entrada.close();
        } catch (IOException e) {
            // ¿Qué hacer aquí?
        }
    }
}

// Enfoque moderno con try-with-resources
try (InputStream entrada = new FileInputStream("archivo.txt")) {
    // Usar entrada
} catch (IOException e) {
    // Manejar excepción
}

• Mantener el ámbito del try lo más pequeño posible: Incluye solo el código que realmente puede lanzar la excepción.

// Incorrecto - ámbito demasiado amplio
try {
    String datos = obtenerDatos(); // Podría lanzar IOException
    procesarDatos(datos);          // No lanza excepciones
    guardarResultados(datos);      // Podría lanzar SQLException
} catch (Exception e) {
    // Difícil saber qué falló exactamente
}

// Correcto - ámbitos específicos
String datos;
try {
    datos = obtenerDatos();
} catch (IOException e) {
    System.err.println("Error al obtener datos: " + e.getMessage());
    return;
}

procesarDatos(datos);

try {
    guardarResultados(datos);
} catch (SQLException e) {
    System.err.println("Error al guardar resultados: " + e.getMessage());
}

• Evitar anti-patrones comunes:
  • No usar excepciones para controlar el flujo normal del programa
  • No capturar Throwable (excepto en casos muy específicos)
  • No crear excepciones sin mensaje informativo

// Anti-patrón: usar excepciones para control de flujo
public boolean existeArchivo(String ruta) {
    try {
        new FileInputStream(ruta).close();
        return true;
    } catch (IOException e) {
        return false;
    }
}

// Mejor enfoque
public boolean existeArchivo(String ruta) {
    return Files.exists(Path.of(ruta));
}