Come vengono gestiti gli errori in Java e come lavorarci?

In Java, gli errori vengono gestiti utilizzando il meccanismo delle eccezioni. Le eccezioni rappresentano eventi che interrompono il normale flusso di esecuzione del programma. Esistono due tipi di eccezioni: Eccezioni Verificate (Checked Exceptions) ed Eccezioni Non Verificate (Unchecked Exceptions).

Eccezioni Verificate:

• Derivano da java.lang.Exception (eccetto RuntimeException).
• Devono essere gestite (usando try-catch) o dichiarate nella firma del metodo (usando throws).
• Rappresentano errori che possono verificarsi in condizioni normali (ad esempio, IOException, FileNotFoundException).

Eccezioni Non Verificate:

• Derivano da java.lang.RuntimeException o java.lang.Error.
• Non richiedono gestione o dichiarazione obbligatoria.
• Rappresentano errori che spesso indicano errori logici nel codice o stati anomali dell'ambiente di esecuzione (ad esempio, NullPointerException, ArrayIndexOutOfBoundsException).

Gestione delle eccezioni:

Per gestire le eccezioni si utilizzano blocchi try-catch-finally:

• try: Blocco di codice che può generare un'eccezione.
• catch: Blocco di codice che viene eseguito se nel try si verifica un'eccezione del tipo specificato. È possibile avere più blocchi catch per diversi tipi di eccezioni.
• finally: Blocco di codice che viene eseguito indipendentemente dal fatto che si sia verificata o meno un'eccezione. Viene spesso usato per liberare risorse (ad esempio, chiudere file, connessioni).

try {
    // Codice che può generare un'eccezione
    int result = 10 / 0; // Esempio: ArithmeticException
} catch (ArithmeticException e) {
    // Gestione di ArithmeticException
    System.err.println("Errore di divisione per zero: " + e.getMessage());
    // È possibile registrare l'errore, mostrare un messaggio all'utente, ecc.
} catch (Exception e) {
    // Gestione di qualsiasi altra eccezione non ancora gestita
    System.err.println("Si è verificato un errore generale: " + e.getMessage());
} finally {
    // Codice che viene sempre eseguito
    System.out.println("Blocco finally eseguito.");
}

Propagazione delle eccezioni:

Un metodo può dichiarare che può generare una determinata eccezione usando la parola chiave throws:

public void readFile(String filePath) throws FileNotFoundException, IOException {
    // Codice per leggere il file
    // Se il file non viene trovato, può essere lanciata una `FileNotFoundException` (sottoclasse di `IOException`)
    FileReader fr = new FileReader(filePath);
    // Se si verifica un errore di input/output, può essere lanciata una `IOException`
    // ...
}

Il metodo chiamante deve gestire questa eccezione (try-catch) o dichiararla anch'esso con throws.

Creazione di proprie eccezioni:

È possibile creare classi di eccezioni personalizzate che ereditano da Exception (per Eccezioni Verificate) o RuntimeException (per Eccezioni Non Verificate).

public class MyCustomException extends Exception {
    public MyCustomException(String message) {
        super(message);
    }
}

Utilizzo:

public void processData(int value) throws MyCustomException {
    if (value < 0) {
        throw new MyCustomException("Il valore non può essere negativo");
    }
    // Elaborazione dei dati
}

Classi principali di eccezioni (gerarchia):

• java.lang.Throwable (classe base per tutti gli errori e le eccezioni)
  • java.lang.Error (per problemi gravi che di solito non vengono gestiti dal programma, ad esempio OutOfMemoryError)
  • java.lang.Exception (per eccezioni che il programma può gestire)
    • java.lang.RuntimeException (Eccezioni Non Verificate)
      • NullPointerException
      • ArrayIndexOutOfBoundsException
      • ArithmeticException
      • ecc.
    • Altre sottoclassi di Exception (Eccezioni Verificate)
      • IOException
      • FileNotFoundException
      • SQLException
      • ecc.

Lavorare con gli errori implica comprendere questa gerarchia, scegliere il tipo di eccezione appropriato (quando si creano proprie), utilizzare efficacemente try-catch-finally per gestire e propagare le eccezioni, e anche registrare gli errori per il debug.