Spiegazione della gerarchia delle eccezioni in Java

Il termine 'Eccezione' è l'abbreviazione di “evento eccezionale”. In Java, un'eccezione è essenzialmente un evento che si verifica durante l'esecuzione di un programma e interrompe il normale flusso del programma. Le eccezioni sono indesiderate e per lo più impreviste, che generalmente si verificano in fase di esecuzione o in fase di compilazione. Tutte queste eccezioni devono essere gestite per garantire che il programma funzioni nel suo flusso naturale.

Tuttavia, prima di gestire le eccezioni, sarebbe utile sapere quali diversi tipi di eccezioni sono presenti con Java. Attraverso questo articolo, diamo un'occhiata ai vari tipi di eccezioni in Java e alla gerarchia delle eccezioni che seguono.

Gerarchia delle eccezioni in Java

La gerarchia delle eccezioni nel linguaggio di programmazione Java inizia con la classe Throwable, che deriva dalla classe Object ed è la sua sottoclasse diretta, mentre la classe Exception presenta tutta questa classe Throwable che si ramifica ulteriormente in due sottoclassi: Error ed Exception. Ecco un diagramma di flusso per comprendere meglio la gerarchia delle eccezioni Java:

La classe Exception presenta tutte le eccezioni che potresti dover gestire mentre lavori con il linguaggio di programmazione Java. Alcuni esempi comunemente noti e riscontrati di tali eccezioni includono NullPointerException, ClassNotFoundException, IllegalArgumentException, ecc.

D'altra parte, la classe Error si occupa di problemi più gravi nell'architettura del programma Java e non viene curata all'interno del codice dell'applicazione. Alcuni esempi di errori in Java sono InternalError, AssertionError, OutOfMemoryError, ecc.

Le eccezioni in Java sono ulteriormente suddivise in due categorie:

• Eccezioni controllate: sono note anche come eccezioni in fase di compilazione.
• Eccezioni non selezionate: sono anche note come eccezioni di runtime.

Un punto importante da notare a questo punto è che le eccezioni deselezionate sono tutte sottoclassi della classe RuntimeException. Parleremo di più delle eccezioni selezionate e non verificate più avanti in questo articolo. Ma prima, diamo un'occhiata essenzialmente a come Errori ed Eccezioni differiscono nel loro funzionamento in modo che non ci sia confusione.

Errori ed eccezioni in Java: in cosa differiscono?

La documentazione ufficiale del linguaggio di programmazione Java fa riferimento a Errori come occorrenze durante la programmazione Java che "indicano problemi seri che un'applicazione ragionevole non dovrebbe tentare di rilevare". La gravità degli errori è chiara dal modo in cui questa affermazione è pronta. Chiaramente, questo si riferisce all'insieme di problemi che il tuo programma potrebbe incontrare dai quali non è possibile risolverlo senza refactoring del codice o modifica dell'architettura dell'applicazione Java.

Diamo un'occhiata a un metodo Java che genererà un errore:

stampa vuota statica pubblica (String S) {

stampa(S);

}

Nel codice sopra menzionato, il metodo print() agisce come un metodo ricorsivo che continua a chiamarsi ripetutamente, ancora e ancora, fino a raggiungere la dimensione massima consentita per uno stack di thread in Java. A quel punto, esce dall'esecuzione con un molto comune: StackOverflowError, che legge qualcosa del tipo:

Eccezione nel thread "main" java.lang.StackOverflowError

in StackOverflowErrorExample.print(StackOverflowErrorExample.java:3)

Come mostra l'esempio precedente, il metodo genera un esempio, ma questo errore non può essere gestito nel codice stesso. Quindi, il programma interrompe semplicemente l'esecuzione perché il danno è irrecuperabile. Come soluzione, il codice deve essere modificato.

Contrariamente agli errori, le eccezioni indicano condizioni che possono essere rilevate da un'applicazione ragionevole. Le eccezioni in Java includono problemi che potrebbero verificarsi in fase di compilazione o durante l'esecuzione. Queste eccezioni si verificano piuttosto frequentemente in tutte le applicazioni, specialmente durante la fase di test e debug. Di conseguenza, le eccezioni in Java possono essere gestite all'interno del programma stesso per garantire che il codice esegua il suo flusso naturale.

Ora, parliamo un po' di più della gerarchia delle eccezioni in Java osservando quali sono le eccezioni selezionate e deselezionate.

Eccezioni selezionate e non controllate in Java

Come accennato in precedenza, le eccezioni in un programma Java possono verificarsi durante la compilazione o durante l'esecuzione. Questo è ciò che ci fornisce i due grandi tipi di eccezioni presenti in Java. Vediamo in dettaglio queste due eccezioni.

Eccezioni in fase di compilazione

Le eccezioni che si verificano in fase di compilazione sono note come eccezioni in fase di compilazione. Queste sono anche chiamate eccezioni verificate a causa del fatto che è necessario verificarle esplicitamente nel programma Java e gestirle nel codice stesso. Classi come InterruptedException, IOException e altre sono eccezioni controllate.

Diamo un'occhiata a un metodo in grado di gestire un'eccezione verificata:

public void writeAFile() {

try (BufferedWriter b_w = new BufferedWriter(new FileWriter(“myFile.txt”))) {

b_w.write("Test");

} cattura (IOException ioe) {

ioe.printStackTrace();

}

}

Come puoi vedere, ci sono due istruzioni nel blocco try del codice sopra:

• Istanziazione dell'oggetto – BufferedWriter
• Utilizzo dell'oggetto per scrivere nel file

Entrambe queste istruzioni possono generare IOException. IOException, essendo un'eccezione verificata, deve essere gestita dal chiamante o dal metodo. Nell'esempio precedente, puoi vedere l'eccezione gestita all'interno del metodo stesso.

Eccezioni di runtime

Contrariamente alle eccezioni in fase di compilazione generate durante la fase di compilazione, le eccezioni di runtime o non controllate possono essere generate "in qualsiasi momento", il che significa essenzialmente in fase di esecuzione. Di conseguenza, i metodi non devono utilizzare in modo esplicito blocchi catch-and-throw per gestire queste eccezioni non controllate. Alcune delle classi che ereditano le eccezioni di runtime non controllate includono – NullPointerException, ArithmeticException, ecc.

Diamo un'occhiata a un pezzo di codice Java che genera un'eccezione non controllata NullPointerException e che non viene gestita nel pezzo di codice a differenza di prima. Ecco qui:

public void writeToFile() {

prova (BufferedWriter b_w = null) {

b_w.write("Test");

} cattura (IOException ioe) {

ioe.printStackTrace();

}

}

Quando si chiama il metodo precedente, il programma genererà un'eccezione NullPointerException poiché l'oggetto BufferedWriter è null. Ecco come sarebbe l'eccezione:

Eccezione nel thread "main" java.lang.NullPointerException

in IOExceptionExample.writeToFile(IOExceptionExample.java:10)

in IOExceptionExample.main(IOExceptionExample.java:17)

In conclusione

Con questo, arriviamo alla fine di questo blog sulla comprensione della gerarchia delle eccezioni in Java. Tieni presente che questa non è affatto una copertura completa delle eccezioni in Java e di come gestirle. Per questo, dovresti scavare più a fondo ed esporti a diverse possibili eccezioni per vedere come funzionano. Conoscere la gestione delle eccezioni ti preparerà per una carriera di successo come sviluppatore full-stack poiché le eccezioni costituiscono le basi di qualsiasi applicazione.

In upGrad, abbiamo un corso specializzato di sviluppo full stack - Programma Executive PG in Software Development - Specializzazione in Full Stack Development - in cui ti guidiamo attraverso tutte le sfumature dello sviluppo del software concentrandoti principalmente sullo sviluppo di Full Stack. Ti consigliamo di dare un'occhiata al corso e probabilmente di prenotare presto un posto!