Sintassi di try- catch

1. A cosa serve try-catch?

Come già sai, in programmazione gli errori capitano continuamente: divisione per zero, input non valido, assenza di un file, ecc. Se tali situazioni non vengono gestite, il programma terminerà con errore (crash).
La costruzione try-catch consente di “catturare” un’eccezione e prevenire l’arresto del programma, gestendo l’errore in modo ordinato.

Sintassi della costruzione try-catch

try 
{
    // Codice che può generare un'eccezione
} 
catch (TipIsklyucheniya imyaPeremennoy) 
{
    // Codice per gestire l'eccezione
}

Spiegazione:

• try — “prova a eseguire questo codice”.
• catch — “se si verifica un’eccezione del tipo indicato, gestiscila qui”.

Come funziona?

Se nel blocco try si verifica un’eccezione, l’esecuzione di quel blocco viene immediatamente interrotta e il controllo passa al primo blocco catch adatto. Se non si verifica alcuna eccezione, il blocco catch viene saltato.

2. Esempio: divisione per zero

Senza gestione dell’eccezione

int a = 10;
int b = 0;
int result = a / b; // Qui il programma terminerà con un errore!
System.out.println("Risultato: " + result); // Non arriveremo fin qui

Risultato:

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

Con gestione tramite try-catch

int a = 10;
int b = 0;

try 
{
    int result = a / b; // Qui può verificarsi un'eccezione
    System.out.println("Risultato: " + result);
} 
catch (ArithmeticException e) 
{
    System.out.println("Errore: divisione per zero impossibile!");
}

System.out.println("Il programma ha continuato l'esecuzione.");

Risultato:

Errore: divisione per zero impossibile!
Il programma ha continuato l'esecuzione.

Spiegazione:

1. Non appena Java incontra una divisione per zero, “lancia” un’eccezione.
2. try viene interrotto e il controllo passa a catch.
3. Dopo la gestione dell’errore il programma continua l’esecuzione.

3. Come funziona il blocco catch

Tra parentesi dopo catch si specificano il tipo di eccezione (per esempio, ArithmeticException) e il nome della variabile (di solito e).

Dentro al blocco catch puoi ottenere dettagli sull’errore:

• e.getMessage() — breve descrizione dell’errore.
• e.printStackTrace() — informazioni dettagliate (per il debug).

Esempio:

try 
{
    int[] arr = new int[2];
    int x = arr[10]; // Errore: l'indice non esiste
} 
catch (ArrayIndexOutOfBoundsException e) 
{
    System.out.println("Errore: " + e.getMessage()); // Stampiamo il messaggio dell'errore
    e.printStackTrace();                             // Stampiamo in console tutte le informazioni sull'errore
}

4. Flusso di esecuzione in caso di eccezione

Se nel blocco try non ci sono errori, il blocco catch viene saltato.

Se nel blocco try si verifica un errore, l’esecuzione del blocco si interrompe nel punto dell’errore e il controllo passa subito al primo catch adatto. Tutto ciò che si trova dopo l’errore nel try non verrà eseguito!

Illustrazione:

try 
{
    System.out.println("1. Inizio di try");
    int a = 10 / 0;                        // Errore!
    System.out.println("2. Dopo la divisione"); // Non verrà eseguito
} 
catch (ArithmeticException e) 
{
    System.out.println("3. Nel blocco catch");
}
System.out.println("4. Dopo try-catch");

Risultato:

1. Inizio di try
3. Nel blocco catch
4. Dopo try-catch

5. Errori tipici nell’uso di try-catch

Errore n. 1: catch troppo generico.
Se usi catch (Exception e), potresti intercettare un sacco di errori imprevisti che non sei in grado di gestire correttamente.
Soluzione: intercetta solo le eccezioni realmente attese in quel punto (per esempio, IOException, SQLException).

Errore n. 2: catch vuoto.
Scrivere catch (Exception e) {} — significa nascondere il problema. Il programma si arresterà altrove o si comporterà in modo anomalo.
Soluzione: almeno registra l’errore (e.printStackTrace() o un logger).

Errore n. 3: credere che try-catch risolva qualsiasi problema.
Se l’errore è nella logica del programma (per esempio, divisione per zero, algoritmo errato), nessun try-catch potrà aiutare.
Soluzione: usa try-catch solo per situazioni realmente previste, non per mascherare bug.