logo

TechCodeview

Eccezioni in Java

La gestione delle eccezioni in Java è uno dei mezzi efficaci per gestire gli errori di runtime in modo da poter preservare il flusso regolare dell'applicazione. Java Exception Handling è un meccanismo per gestire errori di runtime come ClassNotFoundException, IOException, SQLException, RemoteException, ecc.

Cosa sono le eccezioni Java?

In Java, eccezione è un evento indesiderato o inaspettato, che si verifica durante l’esecuzione di un programma, cioè in fase di esecuzione, che interrompe il normale flusso delle istruzioni del programma. Le eccezioni possono essere rilevate e gestite dal programma. Quando si verifica un'eccezione all'interno di un metodo, crea un oggetto. Questo oggetto è chiamato oggetto eccezione. Contiene informazioni sull'eccezione, come il nome e la descrizione dell'eccezione e lo stato del programma quando si è verificata l'eccezione.

Motivi principali per cui si verifica un'eccezione

  • Immissione utente non valida
  • Guasto del dispositivo
  • Perdita di connessione di rete
  • Limitazioni fisiche (memoria su disco insufficiente)
  • Errori di codice
  • Apertura di un file non disponibile

Errori rappresentano condizioni irrecuperabili come l'esaurimento della memoria della Java virtual machine (JVM), perdite di memoria, errori di overflow dello stack, incompatibilità delle librerie, ricorsione infinita, ecc. Gli errori sono solitamente fuori dal controllo del programmatore e non dovremmo provare a gestire gli errori.



Differenza tra errore ed eccezione

Parliamo della parte più importante che è il differenze tra errore ed eccezione cioè il seguente:

  • Errore: Un errore indica un problema serio che un'applicazione ragionevole non dovrebbe tentare di rilevare.
  • Eccezione: L'eccezione indica le condizioni che un'applicazione ragionevole potrebbe tentare di rilevare.

Gerarchia delle eccezioni

Tutti i tipi di eccezioni ed errori sono sottoclassi della classe Lanciabile , che è la classe base della gerarchia. Un ramo è diretto da Eccezione . Questa classe viene utilizzata per condizioni eccezionali che i programmi utente dovrebbero rilevare. NullPointerException è un esempio di tale eccezione. Un altro ramo, Errore è utilizzato dal sistema runtime Java( JVM ) per indicare errori che hanno a che fare con l'ambiente di runtime stesso (JRE). StackOverflowError è un esempio di tale errore.

Gerarchia delle eccezioni in Java

Gerarchia delle eccezioni Java

Tipi di eccezioni

Java definisce diversi tipi di eccezioni relative alle sue varie librerie di classi. Java consente inoltre agli utenti di definire le proprie eccezioni.

tipi di eccezioni in Java

Le eccezioni possono essere classificate in due modi:

  1. Eccezioni integrate
    • Eccezione controllata
    • Eccezione non controllata
  2. Eccezioni definite dall'utente

Parliamo dell'eccezione sopra definita che è la seguente:

1. Eccezioni integrate

Le eccezioni integrate sono le eccezioni disponibili nelle librerie Java. Queste eccezioni sono adatte a spiegare determinate situazioni di errore.

  • Eccezioni verificate: Le eccezioni controllate sono chiamate eccezioni in fase di compilazione perché queste eccezioni vengono controllate in fase di compilazione dal compilatore.
  • Eccezioni non controllate: Le eccezioni non controllate sono esattamente opposte alle eccezioni controllate. Il compilatore non controllerà queste eccezioni in fase di compilazione. In parole semplici, se un programma lancia un’eccezione non controllata, e anche se non la gestiamo o la dichiariamo, il programma non darebbe un errore di compilazione.

Nota: Per le eccezioni verificate e non verificate, vedere Eccezioni verificate e non verificate

2. Eccezioni definite dall'utente:

A volte le eccezioni integrate in Java non sono in grado di descrivere una determinata situazione. In questi casi, gli utenti possono anche creare eccezioni, chiamate “Eccezioni definite dall’utente”.

IL vantaggi della gestione delle eccezioni in Java sono come segue:

  1. Fornitura per completare l'esecuzione del programma
  2. Facile identificazione del codice di programma e del codice di gestione degli errori
  3. Propagazione degli errori
  4. Segnalazione errori significativi
  5. Identificazione dei tipi di errore

Metodi per stampare le informazioni sull'eccezione:

1. stampaStackTrace()

Questo metodo stampa le informazioni sull'eccezione nel formato Nome dell'eccezione: descrizione dell'eccezione, analisi dello stack.

Esempio:

Giava




//program to print the exception information using printStackTrace() method> > import> java.io.*;> > class> GFG {> >public> static> void> main (String[] args) {> >int> a=>5>;> >int> b=>0>;> >try>{> >System.out.println(a/b);> >}> >catch>(ArithmeticException e){> >e.printStackTrace();> >}> >}> }> 

>

>

convertire la data della stringa

Produzione 

java.lang.ArithmeticException: / by zero at GFG.main(File.java:10)>

2. toString()

Il metodo toString() stampa le informazioni sull'eccezione nel formato Nome dell'eccezione: descrizione dell'eccezione.

Esempio:

Giava




//program to print the exception information using toString() method> > import> java.io.*;> > class> GFG1 {> >public> static> void> main (String[] args) {> >int> a=>5>;> >int> b=>0>;> >try>{> >System.out.println(a/b);> >}> >catch>(ArithmeticException e){> >System.out.println(e.toString());> >}> >}> }> 

>

>

Produzione 

java.lang.ArithmeticException: / by zero>

3. getMessaggio()

Il metodo getMessage() stampa solo la descrizione dell'eccezione.

Esempio:

Giava




//program to print the exception information using getMessage() method> > import> java.io.*;> > class> GFG1 {> >public> static> void> main (String[] args) {> >int> a=>5>;> >int> b=>0>;> >try>{> >System.out.println(a/b);> >}> >catch>(ArithmeticException e){> >System.out.println(e.getMessage());> >}> >}> }> 

>

>

Produzione 

/ by zero>

In che modo JVM gestisce un'eccezione?

Gestione delle eccezioni predefinita: Ogni volta all'interno di un metodo, se si è verificata un'eccezione, il metodo crea un oggetto noto come oggetto eccezione e lo trasmette al sistema runtime (JVM). L'oggetto eccezione contiene il nome e la descrizione dell'eccezione e lo stato corrente del programma in cui si è verificata l'eccezione. La creazione dell'oggetto eccezione e la sua gestione nel sistema runtime vengono chiamate generazione di un'eccezione. Potrebbe esserci un elenco dei metodi che sono stati chiamati per arrivare al metodo in cui si è verificata un'eccezione. Questo elenco ordinato di metodi viene chiamato Stack di chiamate . Ora avverrà la seguente procedura.

  • Il sistema runtime cerca nello stack di chiamate per trovare il metodo che contiene un blocco di codice in grado di gestire l'eccezione che si è verificata. Il blocco del codice si chiama an Gestore delle eccezioni .
  • Il sistema di runtime avvia la ricerca dal metodo in cui si è verificata l'eccezione e procede attraverso lo stack di chiamate nell'ordine inverso in cui sono stati chiamati i metodi.
  • Se trova un gestore appropriato, gli passa l'eccezione che si è verificata. Un gestore appropriato significa che il tipo di oggetto eccezione generato corrisponde al tipo di oggetto eccezione che può gestire.
  • Se il sistema runtime cerca tutti i metodi nello stack di chiamate e non riesce a trovare il gestore appropriato, il sistema runtime consegna l'oggetto eccezione al gestore di eccezioni predefinito , che fa parte del sistema di runtime. Questo gestore stampa le informazioni sull'eccezione nel formato seguente e termina il programma in modo anomalo .
Exception in thread 'xxx' Name of Exception : Description ... ...... .. // Call Stack>

Guarda il diagramma seguente per comprendere il flusso dello stack di chiamate.

Flusso dello stack di classi per le eccezioni in Java

Illustrazione:

Giava

operatore Java




// Java Program to Demonstrate How Exception Is Thrown> > // Class> // ThrowsExecp> class> GFG {> > >// Main driver method> >public> static> void> main(String args[])> >{> >// Taking an empty string> >String str =>null>;> >// Getting length of a string> >System.out.println(str.length());> >}> }> 

>

>

Produzione

uscita del programma

Vediamo un esempio che illustra come un sistema runtime cerca il codice appropriato per la gestione delle eccezioni nello stack di chiamate.

Esempio:

Giava




// Java Program to Demonstrate Exception is Thrown> // How the runTime System Searches Call-Stack> // to Find Appropriate Exception Handler> > // Class> // ExceptionThrown> class> GFG {> > >// Method 1> >// It throws the Exception(ArithmeticException).> >// Appropriate Exception handler is not found> >// within this method.> >static> int> divideByZero(>int> a,>int> b)> >{> > >// this statement will cause ArithmeticException> >// (/by zero)> >int> i = a / b;> > >return> i;> >}> > >// The runTime System searches the appropriate> >// Exception handler in method also but couldn't have> >// found. So looking forward on the call stack> >static> int> computeDivision(>int> a,>int> b)> >{> > >int> res =>0>;> > >// Try block to check for exceptions> >try> {> > >res = divideByZero(a, b);> >}> > >// Catch block to handle NumberFormatException> >// exception Doesn't matches with> >// ArithmeticException> >catch> (NumberFormatException ex) {> >// Display message when exception occurs> >System.out.println(> >'NumberFormatException is occurred'>);> >}> >return> res;> >}> > >// Method 2> >// Found appropriate Exception handler.> >// i.e. matching catch block.> >public> static> void> main(String args[])> >{> > >int> a =>1>;> >int> b =>0>;> > >// Try block to check for exceptions> >try> {> >int> i = computeDivision(a, b);> >}> > >// Catch block to handle ArithmeticException> >// exceptions> >catch> (ArithmeticException ex) {> > >// getMessage() will print description> >// of exception(here / by zero)> >System.out.println(ex.getMessage());> >}> >}> }> 

>

>

Produzione 

/ by zero>

In che modo il programmatore gestisce un'eccezione?

Gestione delle eccezioni personalizzata: La gestione delle eccezioni Java è gestita tramite cinque parole chiave: Tentativo , presa , gettare , lancia , E Finalmente . In breve, ecco come funzionano. Le istruzioni del programma che si ritiene possano sollevare eccezioni sono contenute all'interno di un blocco try. Se si verifica un'eccezione all'interno del blocco try, viene lanciata. Il tuo codice può catturare questa eccezione (usando catch block) e gestirla in modo razionale. Le eccezioni generate dal sistema vengono generate automaticamente dal sistema runtime Java. Per lanciare manualmente un'eccezione, utilizzare la parola chiave Throw. Qualsiasi eccezione espulsa da un metodo deve essere specificata come tale da una clausola Throws. Qualsiasi codice che deve assolutamente essere eseguito dopo il completamento del blocco try viene inserito in un blocco final.

Mancia: Bisogna passare attraverso flusso di controllo nel tentativo di catturare infine bloccare per una migliore comprensione.

Necessità della clausola try-catch (gestione delle eccezioni personalizzata)

Considera il programma seguente per comprendere meglio la clausola try-catch.

Esempio:

Giava




// Java Program to Demonstrate> // Need of try-catch Clause> > // Class> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> >// Taking an array of size 4> >int>[] arr =>new> int>[>4>];> > >// Now this statement will cause an exception> >int> i = arr[>4>];> > >// This statement will never execute> >// as above we caught with an exception> >System.out.println(>'Hi, I want to execute'>);> >}> }> 

>

>

Produzione

uscita del programma

Spiegazione dell'output: Nell'esempio sopra, un array è definito con dimensione, ovvero puoi accedere agli elementi solo dall'indice da 0 a 3. Ma se stai tentando di accedere agli elementi dell'indice 4 (per errore), ecco perché viene generata un'eccezione. In questo caso, JVM termina il programma in modo anomalo . L'istruzione System.out.println(Ciao, voglio eseguire); non verrà mai eseguito. Per eseguirlo, dobbiamo gestire l'eccezione usando try-catch. Quindi per continuare il normale flusso del programma, abbiamo bisogno di una clausola try-catch.

Come utilizzare la clausola Try-catch? 

try {  // block of code to monitor for errors  // the code you think can raise an exception } catch (ExceptionType1 exOb) {  // exception handler for ExceptionType1 } catch (ExceptionType2 exOb) {  // exception handler for ExceptionType2 } // optional finally { // block of code to be executed after try block ends  }>

È necessario ricordare alcuni punti chiave che sono i seguenti:

  • In un metodo, può esserci più di un'istruzione che potrebbe generare un'eccezione, quindi inserisci tutte queste istruzioni all'interno di una propria Tentativo bloccare e fornire un gestore di eccezioni separato all'interno del proprio presa blocco per ciascuno di essi.
  • Se si verifica un'eccezione all'interno del file Tentativo blocco, l'eccezione viene gestita dal gestore eccezioni ad essa associato. Per associare il gestore delle eccezioni, dobbiamo inserire a presa bloccare dopo di esso. Può esserci più di un gestore di eccezioni. Ogni presa block è un gestore di eccezioni che gestisce l'eccezione del tipo indicato dal suo argomento. L'argomento ExceptionType dichiara il tipo di eccezione che può gestire e deve essere il nome della classe che eredita da Lanciabile classe.
  • Per ogni blocco try possono esserci zero o più blocchi catch, ma solo uno blocco finale.
  • Il blocco infine è facoltativo. Viene sempre eseguito indipendentemente dal fatto che si sia verificata un'eccezione nel blocco try o meno. Se si verifica un'eccezione, verrà eseguita successivamente provare a prendere i blocchi. E se non si verifica un'eccezione, verrà eseguita dopo il Tentativo bloccare. Il blocco final in Java viene utilizzato per inserire codici importanti come il codice di pulizia, ad esempio la chiusura del file o la chiusura della connessione.
  • Se scriviamo System.exit nel blocco try, il blocco finale non verrà eseguito.

Il riepilogo è rappresentato tramite un aiuto visivo di seguito come segue:

fcfs
Eccezioni in Java

Articoli Correlati:

Corsi correlati

Java Programming Foundation – Corso personalizzato

Trova il corso giusto per iniziare ad apprendere Java Programming Foundation tenuto da esperti del settore con anni di esperienza. Questo Java Programming Foundation – Corso personalizzato copre i fondamenti del Linguaggio di programmazione Java, tipi di dati, operatori e controllo di flusso, loop, stringhe , e altro ancora. Niente più attese! Inizia subito a imparare Java e diventa un ingegnere Java completo!