Pila de llamadas (Stack trace)

1. Introducción

Stack trace (pila de llamadas) — es la lista de métodos que se han invocado en tu programa hasta el momento en que ocurrió un error (excepción). Cuando en el programa se produce una excepción, Java muestra automáticamente el stack trace en pantalla. Es como «huellas en la nieve»: ves por qué pasos llegó el programa al error.

Analogía:
Imagina que vas por un laberinto y de repente te topas con una pared. El stack trace es un mapa que muestra por qué pasillos caminaste antes de perderte.

¿Cómo se ve un stack trace?

Cuando en el programa ocurre un error, Java muestra un mensaje parecido a este:

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

¿Qué pone aquí?

• Exception in thread "main" — en qué hilo se produjo el error (normalmente "main").
• java.lang.ArithmeticException: / by zero — tipo de excepción y su mensaje.
• at Main.divide(Main.java:10) — método divide en la clase Main, línea 10.
• at Main.main(Main.java:5) — método main en la clase Main, línea 5.

Cada línea at ... es un paso en el stack de llamadas. La línea superior es el lugar donde ocurrió el error. Debajo están los métodos que llamaron a ese método, y así sucesivamente hasta el inicio del programa.

2. ¿Cómo leer un stack trace?

Paso 1. Encuentra el tipo de excepción y el mensaje

La primera línea siempre contiene el tipo de error y su descripción:

java.lang.ArithmeticException: / by zero

Esto ya es una pista: el error está relacionado con una división por cero.

Paso 2. Mira la primera línea «at ...»

Este es el lugar donde realmente se produjo el error:

at Main.divide(Main.java:10)

Significa que el error ocurrió en el método divide de la clase Main en la línea 10.

Paso 3. Sube por la pila

La siguiente línea muestra quién llamó a ese método:

at Main.main(Main.java:5)

Significa que el método main llamó a divide, y el error «subió». Número de línea: 5.

Paso 4. Busca tus clases

En un stack trace largo a menudo aparecen métodos del sistema (por ejemplo, de los paquetes java.util, java.io).
Tus clases suelen estar más cerca del principio de la lista. Mira los nombres de clases y archivos: ¡busca los tuyos!

3. Ejemplo: análisis de un stack trace real

Código:

public class Main 
{
    public static void main(String[] args) 
    {
        int result = divide(10, 0);
        System.out.println("Resultado: " + result);
    }

    public static int divide(int a, int b) 
    {
        return a / b;
    }
}

Error:

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

Analicemos:

• Error: división por cero (ArithmeticException).
• Ocurrió en el método divide en la línea 8.
• Invocada desde el método main en la línea 3.

¿Qué hacer?
Abrimos el archivo Main.java, vamos a la línea 8 y encontramos la división por cero. ¡Lo corregimos!

4. Stack trace con varios métodos

Código:

public class Main 
{
    public static void main(String[] args) 
    {
        process();
    }

    public static void process() 
    {
        calculate();
    }

    public static void calculate() 
    {
        int[] arr = {1, 2, 3};
        System.out.println(arr[10]); // Error!
    }
}

Error:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 10 out of bounds for length 3
    at Main.calculate(Main.java:11)
    at Main.process(Main.java:7)
    at Main.main(Main.java:3)

Analicemos:

• Error: índice fuera de los límites del array (ArrayIndexOutOfBoundsException).
• Ocurrió en calculate (línea 11).
• Invocada desde process (línea 7).
• Invocada desde main (línea 3).

Conclusión:
El stack trace muestra todo el camino por el que el programa llegó al error.

5. Errores típicos al trabajar con el stack trace

Error n.º 1: ignorar el stack trace.
Los principiantes a menudo solo miran el «error en rojo» y no leen la pila de llamadas. ¡No lo hagas! Stack trace es una pista sobre dónde buscar el error.

Error n.º 2: confundir la línea del tipo de error con la línea donde ocurrió.
Importante: la primera línea es el tipo de error, y el lugar del error está en la primera línea at ....

Error n.º 3: buscar el error en las clases del sistema.
Si ves líneas como at java.base/java.util.Scanner.nextInt(Scanner.java:123), no te apresures a meterte en el código fuente de Java. Mira quién llamó a ese método en tu propio código.

Error n.º 4: no usar los números de línea.
El número de línea es tu mejor aliado. Abre el archivo, ve a la línea correspondiente y verás el error.

Error n.º 5: no entender que el stack trace es un «camino».
El stack trace muestra cómo llegó el programa al error. A veces el fallo no está en la línea superior, sino en cómo has llamado al método.