Traccia dello stack (Stack Trace)

1. Introduzione

Stack Trace (traccia dello stack) — è l’elenco dei metodi che sono stati chiamati nel tuo programma fino al momento in cui si è verificato un errore (eccezione). Quando nel programma si verifica un’eccezione, Java stampa automaticamente la traccia dello stack a schermo. È come «impronte sulla neve»: vedi quali passi ha fatto il programma per arrivare all’errore.

Analogia:
Immagina di percorrere un labirinto e all’improvviso ti imbatti in un muro. Lo stack trace è una mappa che mostra in quali corridoi sei passato prima di perderti.

Come si presenta uno Stack Trace?

Quando nel programma si verifica un errore, Java stampa più o meno questo messaggio:

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

Che cosa c’è scritto qui?

• Exception in thread "main" — in quale thread si è verificato l’errore (di solito "main").
• java.lang.ArithmeticException: / by zero — tipo di eccezione e suo messaggio.
• at Main.divide(Main.java:10) — il metodo divide nella classe Main, riga 10.
• at Main.main(Main.java:5) — il metodo main nella classe Main, riga 5.

Ogni riga at ... è un passo nella traccia dello stack. La riga più in alto è il punto in cui si è verificato l’errore. Più sotto ci sono i metodi che hanno chiamato quel metodo, e così via fino all’inizio del programma.

2. Come leggere uno Stack Trace?

Passo 1. Trova il tipo di eccezione e il messaggio

La prima riga contiene sempre il tipo di errore e la sua descrizione:

java.lang.ArithmeticException: / by zero

È già un indizio: l’errore è legato a una divisione per zero.

Passo 2. Guarda la prima riga «at ...»

Questo è il punto in cui si è effettivamente verificato l’errore:

at Main.divide(Main.java:10)

Quindi l’errore è avvenuto nel metodo divide della classe Main alla riga 10.

Passo 3. Risali lo stack

La riga successiva mostra chi ha chiamato questo metodo:

at Main.main(Main.java:5)

Quindi il metodo main ha chiamato divide e l’errore è «risalito» verso l’alto. Numero di riga — 5.

Passo 4. Cerca le tue classi

In una traccia dello stack lunga compaiono spesso metodi di sistema (per esempio, dai pacchetti java.util, java.io).
Le tue classi di solito sono più vicine all’inizio dell’elenco. Guarda i nomi delle classi e dei file — cerca i tuoi!

3. Esempio: analisi di uno Stack Trace reale

Codice:

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

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

Errore:

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

Analizziamo:

• Errore: divisione per zero (ArithmeticException).
• Si è verificato nel metodo divide alla riga 8.
• Chiamata dal metodo main alla riga 3.

Cosa fare?
Apri il file Main.java, vai alla riga 8 — trovi la divisione per zero. Correggi!

4. Stack Trace con più metodi

Codice:

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]); // Errore!
    }
}

Errore:

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)

Analizziamo:

• Errore: indice fuori dai limiti dell’array (ArrayIndexOutOfBoundsException).
• Si è verificato in calculate (riga 11).
• Chiamata da process (riga 7).
• Chiamata da main (riga 3).

Conclusione:
Lo stack trace mostra l’intero percorso che ha portato il programma all’errore.

5. Errori tipici nell’uso dello Stack Trace

Errore n. 1: Ignorare lo Stack Trace.
I principianti spesso guardano solo l’«errore in rosso» e non leggono la traccia dello stack. Non fatelo! Stack trace — è un indizio su dove cercare il bug.

Errore n. 2: Confondere la riga dell’errore e la riga del punto dell’errore.
Importante: la prima riga indica il tipo di errore, mentre il luogo dell’errore è nella prima riga at ....

Errore n. 3: Cercare l’errore nelle classi di sistema.
Se vedi righe del tipo at java.base/java.util.Scanner.nextInt(Scanner.java:123), non correre a guardare i sorgenti di Java. Guarda chi ha chiamato quel metodo nel tuo codice.

Errore n. 4: Non usare i numeri di riga.
Il numero di riga — il tuo miglior alleato. Apri il file, trova la riga giusta — e vedrai l’errore.

Errore n. 5: Non capire che lo Stack Trace è un «percorso».
Lo stack trace mostra come il programma è arrivato all’errore. A volte il bug non è nella riga in cima, ma nel modo in cui hai chiamato il metodo.