Java try-catch: Maneja excepciones sin que el programa se caiga

Capturar una excepción en lugar de caerse

Ya sabes que cuando algo sale mal, Java lanza una excepción, y una excepción no manejada detiene tu programa con un stack trace. Un bloque try-catch es la forma de tomar el control: envuelves el código riesgoso en try, y si lanza una excepción, Java salta al bloque catch que coincide en lugar de caerse.

public class Main {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;          // lanza ArithmeticException
            System.out.println(result);   // nunca se alcanza
        } catch (ArithmeticException e) {
            System.out.println("Cannot divide by zero");
        }

        System.out.println("Program keeps running");
    }
}

En el momento en que 10 / 0 lanza la excepción, el resto del bloque try se omite y el control pasa al catch. Después de que el catch termina, la ejecución continúa con normalidad: el programa no muere.

La variable del catch contiene la excepción

La e en catch (ArithmeticException e) es un objeto real. Lleva información sobre lo que salió mal, siendo lo más útil un mensaje:

public class Main {
    public static void main(String[] args) {
        try {
            int n = Integer.parseInt("not a number");
            System.out.println(n);
        } catch (NumberFormatException e) {
            System.out.println("Bad input: " + e.getMessage());
        }
    }
}

e.getMessage() devuelve una descripción breve. Durante la depuración, e.printStackTrace() vuelca el rastreo completo mostrando exactamente de dónde vino la excepción; úsalo cuando un mensaje por sí solo no baste para encontrar la causa.

Captura el tipo específico, no todo

Un bloque catch solo captura excepciones que coinciden con su tipo declarado (o una subclase). El mayor error de los principiantes es capturar Exception para hacer que un problema "desaparezca":

// No hagas esto: oculta bugs reales
try {
    doWork();
} catch (Exception e) {
    // se traga NullPointerException, erratas, errores de lógica... todo
}

Captura el tipo más estrecho que realmente puedas manejar. Si esperas una entrada numérica incorrecta, captura NumberFormatException. Cualquier cosa que no hayas anticipado debería poder propagarse para que te enteres realmente de ella en lugar de continuar en silencio en un estado roto.

Manejar varios tipos de excepción

Puedes apilar varios bloques catch. Java los revisa de arriba abajo y ejecuta el primero que coincide, así que ordénalos del más específico al más general:

public class Main {
    public static void main(String[] args) {
        String[] inputs = {"42", "oops", null};

        for (String s : inputs) {
            try {
                int n = Integer.parseInt(s);
                System.out.println("Parsed: " + n);
            } catch (NumberFormatException e) {
                System.out.println("Not a number: " + s);
            } catch (NullPointerException e) {
                System.out.println("Got a null value");
            }
        }
    }
}

Cuando dos tipos comparten el mismo manejo, usa un solo multi-catch con | en lugar de duplicar el bloque:

public class Main {
    public static void main(String[] args) {
        try {
            Object[] words = {"a", "b"};
            System.out.println(words[5]);   // ArrayIndexOutOfBoundsException
        } catch (ArrayIndexOutOfBoundsException | NullPointerException e) {
            System.out.println("Bad access: " + e.getClass().getSimpleName());
        }
    }
}

Un detalle a tener en cuenta: un tipo más general debe ir después de los específicos. Poner catch (Exception e) primero hace que los bloques posteriores, más específicos, sean inalcanzables, y el compilador lo rechaza.

finally siempre se ejecuta

Un bloque finally se ejecuta después del try y de cualquier catch, sin importar lo que haya ocurrido: éxito, una excepción capturada o incluso un return anticipado. Es donde corresponde la limpieza que siempre debe ocurrir.

public class Main {
    public static void main(String[] args) {
        try {
            System.out.println("Opening resource");
            int x = 1 / 0;                 // lanza una excepción
            System.out.println("Working");  // omitido
        } catch (ArithmeticException e) {
            System.out.println("Caught: " + e.getMessage());
        } finally {
            System.out.println("Closing resource");  // se ejecuta pase lo que pase
        }
    }
}

"Closing resource" se imprime tanto si se dispara la excepción como si no. Evita, eso sí, hacer return desde dentro de finally: puede descartar silenciosamente una excepción o sobrescribir un valor devuelto desde el bloque try.

try-with-resources cierra las cosas por ti

Cuando trabajas con algo que debe cerrarse (un archivo, una conexión de red, una sentencia de base de datos), declararlo dentro de try (...) lo cierra automáticamente cuando el bloque termina, incluso si se lanza una excepción. Funciona con cualquier tipo que implemente AutoCloseable.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Scanner implementa AutoCloseable, así que se cierra automáticamente
        try (Scanner sc = new Scanner("10 20 30")) {
            int sum = 0;
            while (sc.hasNextInt()) {
                sum += sc.nextInt();
            }
            System.out.println("Sum: " + sum);
        }
    }
}

Esto reemplaza el viejo patrón de abrir en try y cerrar en finally, y es menos propenso a errores porque no puedes olvidarte de cerrar. Prefiérelo siempre que estés tratando con un recurso que se pueda cerrar.

No uses excepciones para el flujo de control normal

try-catch es para situaciones excepcionales, no para condiciones ordinarias. Capturar una excepción es más costoso que una simple comprobación, y hace que el código sea más difícil de leer. Si puedes comprobar la condición primero, hazlo así:

// Evita: usar un catch para comprobar si falta una clave
try {
    process(map.get(key).trim());
} catch (NullPointerException e) {
    // manejar la clave faltante
}

// Prefiere: comprobar explícitamente
String value = map.get(key);
if (value != null) {
    process(value.trim());
}

Reserva catch para cosas que están genuinamente fuera de tu control: entrada de usuario incorrecta, archivos faltantes, fallos de red.

Siguiente: NullPointerException

La excepción más común que capturarás (y provocarás) en Java es la NullPointerException: aparece en el instante en que llamas a un método sobre algo que resultó ser null. A continuación profundizaremos en qué exactamente la dispara, cómo leer su stack trace y los hábitos que evitan que ocurra desde el principio.