Eccezioni in Java: errori, stack trace e throw

Cos'è un'eccezione

Un'eccezione è il modo in cui Java dice "qualcosa è andato storto e non posso continuare normalmente". Invece di restituire un valore sbagliato o corrompere in silenzio i tuoi dati, il runtime crea un oggetto eccezione che descrive il problema e lo lancia. L'esecuzione normale si ferma in quel punto e Java inizia a cercare del codice che sappia gestire la situazione.

Se nessuno la gestisce, l'eccezione arriva in cima al programma, la JVM stampa uno stack trace e il processo termina con uno stato diverso da zero.

public class Main {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30};
        System.out.println("before");
        System.out.println(numbers[5]);   // l'indice 5 non esiste
        System.out.println("after");      // non viene mai eseguito
    }
}

Nota che "after" non viene mai stampato. Nell'istante in cui viene valutato numbers[5], viene lanciata una ArrayIndexOutOfBoundsException e il resto di main viene abbandonato: andare oltre l'ultimo indice valido di un array è uno dei modi più comuni per provocare un'eccezione.

Leggere uno stack trace

Quando un'eccezione non viene gestita, ottieni un output come questo. Sembra minaccioso, ma è solo un elenco:

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

Leggilo dall'alto in basso:

• La prima riga è il tipo (ArithmeticException) e un messaggio (/ by zero).
• Ogni riga at ... è uno stack frame. Quello più in alto è il punto in cui l'eccezione è stata davvero lanciata: divide alla riga 8. Sotto c'è il chiamante, main alla riga 4.

La riga at più in alto è quella da guardare per prima. I frame sottostanti rispondono alla domanda "come siamo arrivati qui?"

public class Main {
    static int divide(int a, int b) {
        return a / b;            // lancia un'eccezione quando b vale 0
    }

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

Eseguilo e lo stack trace punta dritto alla riga a / b, poi mostra main come chiamante. Questa catena di chiamate è lo strumento di debug più utile che Java ti offre gratis.

La gerarchia delle eccezioni

Ogni eccezione è un oggetto, e discendono tutte da Throwable. I due rami che contano:

• Error: problemi gravi sollevati dalla JVM, come OutOfMemoryError o StackOverflowError. In genere non li catturi.
• Exception: problemi che il tuo programma può ragionevolmente prevedere e gestire. Al suo interno c'è RuntimeException, il genitore dei bug di tutti i giorni come NullPointerException.

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

Dato che sono vere classi, un'eccezione può portare con sé un messaggio e puoi interrogarla su se stessa:

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() restituisce il testo dopo i due punti nello stack trace; getClass().getSimpleName() ti dà il nome del tipo di eccezione.

Checked e unchecked

È la distinzione che mette più in difficoltà chi inizia.

• Le eccezioni unchecked estendono RuntimeException. Di solito indicano un bug nel tuo codice: un null che non ti aspettavi, un indice sbagliato, una divisione per zero. Il compilatore non ti obbliga a gestirle.
• Le eccezioni checked estendono Exception ma non RuntimeException (per esempio IOException). Rappresentano condizioni fuori dal tuo controllo: un file mancante, una connessione di rete interrotta. Il compilatore ti obbliga a catturarle o a dichiararle.

Se un metodo può lanciare un'eccezione checked, deve dichiararlo con throws, e ogni chiamante deve occuparsene:

public class Main {
    // dichiara che potrebbe fallire con un'eccezione checked
    static void risky() throws Exception {
        throw new Exception("something went wrong");
    }

    public static void main(String[] args) throws Exception {
        risky();   // anche main deve gestirla o dichiararla di nuovo
    }
}

Togli throws Exception da main e il codice non compila nemmeno: è il compilatore che fa rispettare il contratto delle eccezioni checked. Le eccezioni unchecked non lo richiedono mai.

Lanciare le tue eccezioni

Non devi solo reagire alle eccezioni: puoi anche sollevarle tu. Usa throw con un nuovo oggetto eccezione per segnalare che un argomento o uno stato non è valido. È molto meglio che restituire un valore magico come -1 e sperare che il chiamante lo controlli.

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));   // lancia con un messaggio chiaro
    }
}

Includi sempre un messaggio che spieghi cosa non andava e, se possibile, il valore incriminato: quando leggerai lo stack trace in futuro te ne sarai grato. IllegalArgumentException e IllegalStateException sono le due che userai più spesso per validare gli input.

Trappole comuni

• Ingoiare le eccezioni. Catturare un'eccezione e non fare nulla (un blocco vuoto) nasconde i bug. Come minimo registrala nel log; di solito dovresti gestirla o rilanciarla.
• Catturare Exception in modo troppo ampio. Catturare la classe base Exception (o peggio Throwable) può nascondere problemi che non intendevi gestire. Cattura il tipo specifico che ti aspetti.
• Leggere lo stack trace dal basso. Il frame più rilevante è la riga at in alto, non quella in fondo. Parti da lì.
• Confondere Error con Exception. Non cercare di riprenderti da OutOfMemoryError o StackOverflowError; correggi invece la causa di fondo.

Prossimo passo: try-catch

Ora sai cosa sono le eccezioni e come leggerle. La prossima pagina spiega come gestirle davvero: racchiudere il codice rischioso in un blocco try, recuperare in catch ed eseguire il codice di pulizia in finally, così il programma continua invece di bloccarsi.