Gestire le eccezioni in Java: il blocco try-catch

La gestione delle eccezioni è un aspetto fondamentale della programmazione in Java. Utilizzando il costrutto try-catch, gli sviluppatori possono controllare gli errori in modo efficace, consentendo alle applicazioni di continuare a funzionare anche quando si verificano situazioni impreviste.

Il Costrutto Try-Catch

Entriamo subito nel vivo della trattazione per quanto riguarda il costrutto try e catch. Nel blocco try deve essere inserito il codice che potrebbe generare un’eccezione, mentre nel blocco catch viene gestita l’eccezione. Ad esempio, si potrebbe stampare a video un messaggio che notifichi all’utente che si è verificato un errore. Vediamo ora un esempio pratico utilizzando la classe Implementazione:

public class Implementazione {

  public static void main(String args[]) {
    
    int divisione;
    
    OperazioniSuNumeri operazioni = new OperazioniSuNumeri();
    
    try {
      divisione = operazioni.divisione(5,0);
      System.out.println("Il risultato della divisione è:" + divisione);
    }
    catch (Exception exc) {
      System.out.println(exc);
      System.out.println("Non puoi effettuare una divisione per zero");
    }
    
    System.out.println("Ho terminato comunque l'esecuzione del programma"); 
  } 
}

Nel codice sopra, il metodo divisione, che può generare un’eccezione, è stato inserito all’interno del blocco try. Se il metodo non solleva un’eccezione, il programma procederà alla stampa del risultato della divisione; in caso contrario, verrà eseguito il codice contenuto nel blocco catch.

Analisi della Sintassi di Catch

Andiamo a esaminare la sintassi di catch (Exception exc). Questo costrutto è composto dalla parola chiave catch seguita da un parametro, exc, di tipo Exception. Tale variabile contiene il messaggio di errore dell’eccezione sollevata. Se eseguiamo la classe Implementazione, a video otterremo il seguente output:

java.lang.ArithmeticException: / by zero
Non puoi effettuare una divisione per zero
Ho terminato comunque l'esecuzione del programma

La prima riga rappresenta la stampa relativa alla variabile exc, la seconda il nostro messaggio di errore e la terza la conferma che l’applicazione ha terminato la sua esecuzione. Questo è importante: gestendo l’eccezione, abbiamo garantito che l’applicazione possa completare l’esecuzione correttamente, evitando una terminazione prematura. Anche utilizzando Exception come parametro nel blocco catch, cattureremo qualsiasi eccezione, comprese quelle sollevate dalla JVM.

Buone Pratiche nella Gestione delle Eccezioni

È sempre consigliabile gestire le eccezioni in modo più granulare, prevedendo blocchi catch dedicati per specifiche eccezioni. Vediamo un modo per migliorare la nostra classe Implementazione:

try {
 divisione = operazioni.divisione(5,0);
 System.out.println("Il risultato della divisione è:" + divisione);
}
catch (ArithmeticException exc) {
  System.out.println(exc);
  System.out.println("Non puoi effettuare una divisione per zero");
}
catch (Exception exc) {
  System.out.println("Errore generico");
}

Con questa struttura, quando viene generata un’eccezione, la JVM controllerà i vari blocchi catch. Solo il blocco corrispondente al tipo di eccezione generata verrà eseguito. Se, ad esempio, viene generata un’eccezione di tipo AritmeticException, verrà eseguito il codice del primo blocco catch. Se invece si verifica un’eccezione di altro tipo, la JVM passerà al secondo blocco catch.

L’ordine dei blocchi catch è fondamentale: devono essere scritti dal meno generale al più generale. Se invertissimo l’ordine, l’eccezione verrebbe catturata dal blocco più generico Exception, saltando il blocco specifico per AritmeticException. Questa separazione consente al programmatore di identificare immediatamente la causa del problema e il punto nel codice in cui è avvenuto.