try-catch in Java: gestire le eccezioni senza crash

Catturare un'eccezione invece di andare in crash

Sai già che quando qualcosa va storto Java lancia un'eccezione, e un'eccezione non gestita ferma il programma con uno stack trace. Un blocco try-catch è il modo per prendere il controllo: metti il codice rischioso nel try e, se lancia un'eccezione, Java salta al blocco catch corrispondente invece di andare in crash.

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

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

Nel momento in cui 10 / 0 lancia l'eccezione, il resto del blocco try viene saltato e il controllo passa al catch. Quando il catch finisce, l'esecuzione continua normalmente: il programma non muore.

La variabile del catch contiene l'eccezione

La e in catch (ArithmeticException e) è un oggetto vero. Contiene informazioni su cosa è andato storto, e la più utile è un messaggio:

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() restituisce una breve descrizione. Durante il debug, e.printStackTrace() stampa lo stack trace completo che mostra esattamente da dove è arrivata l'eccezione: usalo quando il solo messaggio non basta per trovare la causa.

Cattura il tipo specifico, non tutto

Un blocco catch cattura solo le eccezioni che corrispondono al tipo dichiarato (o a una sua sottoclasse). L'errore più grande di chi inizia è catturare Exception per far "sparire" un problema:

// Non farlo: nasconde bug reali
try {
    doWork();
} catch (Exception e) {
    // ingoia NullPointerException, errori di battitura, errori di logica... tutto
}

Cattura il tipo più ristretto che sei davvero in grado di gestire. Se ti aspetti un input numerico sbagliato, cattura NumberFormatException. Tutto ciò che non avevi previsto deve poter propagarsi, così te ne accorgi davvero invece di continuare in silenzio in uno stato rotto.

Gestire più tipi di eccezione

Puoi mettere più blocchi catch uno dopo l'altro. Java li controlla dall'alto in basso ed esegue il primo che corrisponde, quindi ordinali dal più specifico al più generale:

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");
            }
        }
    }
}

Quando due tipi richiedono la stessa gestione, usa un solo multi-catch con | invece di duplicare il blocco:

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());
        }
    }
}

Una trappola: un tipo più generale deve venire dopo quelli specifici. Mettere catch (Exception e) per primo rende irraggiungibili i blocchi successivi più specifici, e il compilatore lo rifiuta.

finally viene sempre eseguito

Un blocco finally viene eseguito dopo il try e l'eventuale catch, qualunque cosa sia successa: successo, eccezione catturata o perfino un return anticipato. È il posto giusto per le operazioni di pulizia che devono sempre avvenire.

public class Main {
    public static void main(String[] args) {
        try {
            System.out.println("Opening resource");
            int x = 1 / 0;                 // lancia un'eccezione
            System.out.println("Working");  // saltato
        } catch (ArithmeticException e) {
            System.out.println("Caught: " + e.getMessage());
        } finally {
            System.out.println("Closing resource");  // eseguito in ogni caso
        }
    }
}

"Closing resource" viene stampato che l'eccezione si verifichi o no. Evita però di usare return dentro finally: può scartare in silenzio un'eccezione o sovrascrivere un valore restituito dal blocco try.

try-with-resources chiude le cose al posto tuo

Quando lavori con qualcosa che va chiuso (un file, una connessione di rete, un'istruzione di database), dichiararlo dentro try (...) lo chiude automaticamente alla fine del blocco, anche se viene lanciata un'eccezione. Funziona con qualsiasi tipo che implementa l'interfaccia AutoCloseable.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Scanner implementa AutoCloseable, quindi si chiude automaticamente
        try (Scanner sc = new Scanner("10 20 30")) {
            int sum = 0;
            while (sc.hasNextInt()) {
                sum += sc.nextInt();
            }
            System.out.println("Sum: " + sum);
        }
    }
}

Sostituisce il vecchio schema in cui si apriva nel try e si chiudeva nel finally, ed è meno soggetto a errori perché non puoi dimenticare la chiusura. Preferiscilo ogni volta che hai a che fare con una risorsa da chiudere.

Non usare le eccezioni per il normale flusso di controllo

try-catch serve per situazioni eccezionali, non per condizioni normali. Catturare un'eccezione costa più di un semplice controllo e rende il codice più difficile da leggere. Se puoi verificare prima la condizione con un controllo if-else, fai così:

// Da evitare: usare un catch per verificare se manca una chiave
try {
    process(map.get(key).trim());
} catch (NullPointerException e) {
    // gestisci la chiave mancante
}

// Meglio: controllare in modo esplicito
String value = map.get(key);
if (value != null) {
    process(value.trim());
}

Riserva catch alle cose davvero fuori dal tuo controllo: input sbagliati dell'utente, file mancanti, errori di rete.

Prossima pagina: NullPointerException

L'eccezione più comune che catturerai (e provocherai) in Java è la NullPointerException: compare nell'istante in cui chiami un metodo su qualcosa che si è rivelato null. Nella prossima pagina vedremo esattamente cosa la provoca, come leggere il suo stack trace e le abitudini che impediscono che si verifichi.