Manejo de errores en Java: desde try/catch hasta técnicas avanzadas

Manejo de errores en Java: desde try/catch hasta técnicas avanzadas

El manejo de excepciones es una de las piedras angulares de una aplicación Java confiable. La mayoría de los desarrolladores conocen la construcción básica try-catch-finally, pero a nivel avanzado, Java ofrece herramientas mucho más flexibles y eficientes. En este artículo, analizaremos no solo el enfoque clásico, sino también las capacidades modernas, como multi-catch, try-with-resources, la creación de excepciones personalizadas y estrategias para su manejo. El material está dirigido a desarrolladores que ya escriben con confianza en Java y desean profundizar sus conocimientos.

1. Clásico: try-catch-finally y sus matices

La construcción básica sigue siendo el fundamento. Sin embargo, a nivel avanzado es importante entender cómo funciona internamente y qué errores cometen incluso los programadores experimentados.

Consideremos un ejemplo con entrada/salida de archivos:

import java.io.*;

public class ClassicExample {    public static void main(String[] args) {        BufferedReader reader = null;        try {            reader = new BufferedReader(new FileReader("file.txt"));            String line = reader.readLine();            System.out.println(line);        } catch (IOException e) {            System.err.println("Error de lectura: " + e.getMessage());        } finally {            try {                if (reader != null) {                    reader.close();                }            } catch (IOException e) {                System.err.println("Error al cerrar: " + e.getMessage());            }        }    }}

Puntos clave para nivel avanzado:

• Orden de los bloques catch: las excepciones más específicas deben ir primero. Si colocas Exception antes de IOException, el compilador dará un error.
• El bloque finally siempre se ejecuta, incluso si hay un return en try o catch. Esto es importante para liberar recursos.
• Supresión de excepciones: si ocurre una excepción tanto en try como en finally, la excepción de finally "absorbe" la primera. Para evitarlo, usa Throwable.getSuppressed().

2. Multi-catch: elegancia y legibilidad

A partir de Java 7, surgió la posibilidad de combinar varias excepciones en un solo bloque catch. Esto reduce significativamente la duplicación de código.

Sin multi-catch, el código se ve voluminoso:

try {    // código que puede lanzar IOException o SQLException} catch (IOException e) {    logger.error("Error de entrada/salida", e);    throw new RuntimeException(e);} catch (SQLException e) {    logger.error("Error de base de datos", e);    throw new RuntimeException(e);}

Con multi-catch se vuelve conciso:

try {    // código} catch (IOException | SQLException e) {    logger.error("Error al trabajar con recursos", e);    throw new RuntimeException(e);}

Importante: la variable e en multi-catch es final (o effectively final). No se le puede asignar otro valor. Esto se hizo por seguridad de tipos.

3. Try-with-resources: gestión automática de recursos

Esta es, quizás, la mejora más potente para el manejo de recursos. Cierra automáticamente los recursos que implementan la interfaz AutoCloseable (o Closeable).

Compárelo con el ejemplo clásico anterior. Así es como se ve con try-with-resources:

import java.io.*;

public class TryWithResourcesExample {    public static void main(String[] args) {        try (BufferedReader reader = new BufferedReader(new FileReader("file.txt"));             BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {

            Strin