Excepciones en Java: errores, trazas de pila y lanzamiento

Qué es una excepción

Una excepción es la forma que tiene Java de decir «algo salió mal y no puedo continuar normalmente». En lugar de devolver un valor incorrecto o corromper tus datos en silencio, el entorno de ejecución crea un objeto de excepción que describe el problema y lo lanza. La ejecución normal se detiene en ese punto y Java empieza a buscar código que sepa cómo afrontar la situación.

Si nadie la maneja, la excepción llega a la parte superior de tu programa, la JVM imprime una traza de pila y el proceso termina con un estado distinto de cero.

public class Main {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30};
        System.out.println("before");
        System.out.println(numbers[5]);   // el índice 5 no existe
        System.out.println("after");      // nunca se ejecuta
    }
}

Fíjate en que "after" nunca se imprime. En el instante en que se evalúa numbers[5], se lanza una ArrayIndexOutOfBoundsException y se abandona el resto de main.

Leer una traza de pila

Cuando una excepción queda sin manejar, obtienes una salida como esta. Parece intimidante, pero no es más que una lista:

Exception in thread "main" java.lang.ArithmeticException: / by zero
	at Main.divide(Main.java:8)
	at Main.main(Main.java:4)

Léela de arriba hacia abajo:

• La primera línea es el tipo (ArithmeticException) y un mensaje (/ by zero).
• Cada línea at ... es un marco de pila. La de arriba es donde realmente se lanzó la excepción: divide en la línea 8. Debajo está el llamador, main en la línea 4.

La primera línea at es donde miras primero. Los marcos que hay debajo responden a la pregunta «¿cómo llegamos hasta aquí?».

public class Main {
    static int divide(int a, int b) {
        return a / b;            // lanza una excepción cuando b es 0
    }

    public static void main(String[] args) {
        System.out.println(divide(10, 2));
        System.out.println(divide(10, 0));   // ¡pum!
    }
}

Ejecuta esto y la traza apunta directamente a la línea a / b, y luego muestra main como el llamador. Esa cadena de llamadas es la herramienta de depuración más útil que Java te ofrece gratis.

La jerarquía de excepciones

Toda excepción es un objeto, y todas descienden de Throwable. Las dos ramas que importan:

• Error: problemas graves que lanza la JVM, como OutOfMemoryError o StackOverflowError. Por lo general no los capturas.
• Exception: problemas que tu programa puede anticipar y manejar razonablemente. Dentro de ella se encuentra RuntimeException, la madre de los errores cotidianos como NullPointerException.

Throwable
├── Error                 (don't catch: OutOfMemoryError, StackOverflowError)
└── Exception
    ├── IOException        (checked)
    ├── SQLException       (checked)
    └── RuntimeException   (unchecked)
        ├── NullPointerException
        ├── ArithmeticException
        └── ArrayIndexOutOfBoundsException

Como son clases reales, una excepción puede llevar un mensaje y puedes preguntarle sobre sí misma:

public class Main {
    public static void main(String[] args) {
        try {
            int x = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("type: " + e.getClass().getSimpleName());
            System.out.println("message: " + e.getMessage());
        }
    }
}

getMessage() devuelve el texto que aparece tras los dos puntos en la traza de pila; getClass().getSimpleName() te da el tipo de excepción por su nombre.

Comprobadas frente a no comprobadas

Esta es la distinción que más confunde a los principiantes.

• Las excepciones no comprobadas extienden RuntimeException. Normalmente significan un error en tu código: un null que no esperabas, un índice incorrecto, una división entre cero. El compilador no te obliga a manejarlas.
• Las excepciones comprobadas extienden Exception pero no RuntimeException (por ejemplo, IOException). Representan condiciones fuera de tu control: un archivo que falta, una conexión de red que se cae. El compilador te obliga a capturarlas o a declararlas.

Si un método puede lanzar una excepción comprobada, debe indicarlo con throws, y todo llamador debe ocuparse de ella:

public class Main {
    // declara que podría fallar con una excepción comprobada
    static void risky() throws Exception {
        throw new Exception("something went wrong");
    }

    public static void main(String[] args) throws Exception {
        risky();   // main también debe manejarla o re-declararla
    }
}

Quita throws Exception de main y el código ni siquiera compilará: ese es el compilador imponiendo el contrato de las excepciones comprobadas. Las excepciones no comprobadas nunca requieren esto.

Lanzar las tuyas

No solo reaccionas ante las excepciones, también puedes provocarlas. Usa throw con un nuevo objeto de excepción para indicar que un argumento o un estado no es válido. Esto es mucho mejor que devolver un valor mágico como -1 y esperar que el llamador lo compruebe.

public class Main {
    static int squareRootInput(int n) {
        if (n < 0) {
            throw new IllegalArgumentException("n must be non-negative, got " + n);
        }
        return n;
    }

    public static void main(String[] args) {
        System.out.println(squareRootInput(16));
        System.out.println(squareRootInput(-4));   // lanza con un mensaje claro
    }
}

Incluye siempre un mensaje que explique qué salió mal e, idealmente, el valor problemático: tu yo del futuro, leyendo la traza de pila, te lo agradecerá. IllegalArgumentException e IllegalStateException son las dos que más usarás al validar entradas.

Errores comunes

• Tragarse las excepciones. Capturar una excepción y no hacer nada (un bloque vacío) oculta los errores. Como mínimo regístrala; lo normal es que debas manejarla o relanzarla.
• Capturar Exception de forma demasiado amplia. Capturar la Exception base (o peor, Throwable) puede enmascarar problemas que no querías manejar. Captura el tipo específico que esperas.
• Leer la traza de abajo hacia arriba. El marco más relevante es la línea at de arriba, no la de abajo. Empieza por ahí.
• Confundir Error con Exception. No intentes recuperarte de OutOfMemoryError ni de StackOverflowError; corrige la causa subyacente.

Siguiente: try-catch

Ahora ya sabes qué son las excepciones y cómo leerlas. La siguiente página trata sobre cómo manejarlas de verdad: envolver el código riesgoso en un bloque try, recuperarte en catch y ejecutar código de limpieza en finally para que tu programa siga adelante en lugar de fallar.