Esercizi sulle Eccezioni in Java

Ecco degli esercizi con soluzione per praticare la gestione delle eccezioni in Java.

Esercizio 1: Gestione di un’eccezione semplice

Gestire un'eccezione `ArithmeticException` causata dalla divisione per zero.

public class Divisione {
    public static void main(String[] args) {
        try {
            int risultato = 10 / 0;
            System.out.println("Risultato: " + risultato);
        } catch (ArithmeticException e) {
            System.out.println("Errore: Divisione per zero non permessa.");
        }
    }
}

Esercizio 2: Gestione di più eccezioni

Gestire più tipi di eccezioni nello stesso blocco `try-catch`.

public class GestioneEccezioniMultiple {
    public static void main(String[] args) {
        try {
            int[] array = new int[5];
            System.out.println(array[10]);  // Genera ArrayIndexOutOfBoundsException
            int risultato = 10 / 0;  // Genera ArithmeticException
        } catch (ArrayIndexOutOfBoundsException | ArithmeticException e) {
            System.out.println("Errore: " + e.getMessage());
        }
    }
}

Esercizio 3: Uso del blocco `finally`

Utilizzare il blocco `finally` per eseguire codice che deve essere eseguito indipendentemente dalle eccezioni.

public class UsoFinally {
    public static void main(String[] args) {
        try {
            int risultato = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("Errore: Divisione per zero.");
        } finally {
            System.out.println("Blocco finally eseguito.");
        }
    }
}

Esercizio 4: Creazione di un’eccezione personalizzata

Creare e lanciare un'eccezione personalizzata.

class MiaEccezione extends Exception {
    public MiaEccezione(String messaggio) {
        super(messaggio);
    }
}

public class EccezionePersonalizzata {
    public static void main(String[] args) {
        try {
            lanciaEccezione();
        } catch (MiaEccezione e) {
            System.out.println("Errore: " + e.getMessage());
        }
    }

    public static void lanciaEccezione() throws MiaEccezione {
        throw new MiaEccezione("Questa è un'eccezione personalizzata.");
    }
}

Esercizio 5: Gestione di eccezioni annidate

Gestire eccezioni annidate in un blocco `try-catch`.

public class GestioneEccezioniAnnidate {
    public static void main(String[] args) {
        try {
            try {
                int risultato = 10 / 0;
            } catch (ArithmeticException e) {
                System.out.println("Errore interno: Divisione per zero.");
                throw e;
            }
        } catch (ArithmeticException e) {
            System.out.println("Errore esterno: " + e.getMessage());
        }
    }
}

Esercizio 6: Rilancio di un’eccezione

Rilanciare un'eccezione dopo averla gestita parzialmente.

public class RilancioEccezione {
    public static void main(String[] args) {
        try {
            metodo1();
        } catch (ArithmeticException e) {
            System.out.println("Errore catturato nel main: " + e.getMessage());
        }
    }

    public static void metodo1() {
        try {
            int risultato = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("Errore nel metodo1: " + e.getMessage());
            throw e;  // Rilancia l'eccezione
        }
    }
}

Esercizio 7: Utilizzo di `throws` in un metodo

Dichiarare un metodo che lancia un'eccezione con `throws` e gestirla nel metodo chiamante.

public class UtilizzoThrows {
    public static void main(String[] args) {
        try {
            metodoCheLanciaEccezione();
        } catch (Exception e) {
            System.out.println("Errore: " + e.getMessage());
        }
    }

    public static void metodoCheLanciaEccezione() throws Exception {
        throw new Exception("Eccezione lanciata dal metodo.");
    }
}

Esercizio 8: Eccezioni Verificate e Non Verificate

Dimostrare la differenza tra eccezioni verificate e non verificate.

public class VerificateNonVerificate {
    public static void main(String[] args) {
        // Eccezione non verificata (unchecked)
        try {
            int risultato = 10 / 0;
        } catch (ArithmeticException e) {
            System.out.println("Errore: " + e.getMessage());
        }

        // Eccezione verificata (checked)
        try {
            throw new Exception("Eccezione verificata.");
        } catch (Exception e) {
            System.out.println("Errore: " + e.getMessage());
        }
    }
}

Esercizio 9: Uso delle eccezioni per la validazione

Utilizzare le eccezioni per validare l'input dell'utente.

import java.util.Scanner;

public class ValidazioneInput {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Inserisci un numero positivo: ");
        int numero = scanner.nextInt();

        try {
            validaNumero(numero);
            System.out.println("Numero valido: " + numero);
        } catch (IllegalArgumentException e) {
            System.out.println("Errore: " + e.getMessage());
        }
    }

    public static void validaNumero(int numero) {
        if (numero <= 0) {
            throw new IllegalArgumentException("Il numero deve essere positivo.");
        }
    }
}

Esercizio 10: Creazione di un blocco `try-with-resources`

Utilizzare un blocco `try-with-resources` per gestire automaticamente la chiusura delle risorse.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class TryWithResources {
    public static void main(String[] args) {
        try (BufferedReader br = new BufferedReader(new FileReader("testo.txt"))) {
            String linea;
            while ((linea = br.readLine()) != null) {
                System.out.println(linea);
            }
        } catch (IOException e) {
            System.out.println("Errore di I/O: " + e.getMessage());
        }
    }
}