Gestione delle eccezioni in Java [con esempi]
Pubblicato: 2020-11-12Le eccezioni sono l'evento indesiderato e inaspettato di un programma che non è mai desiderato da un programmatore ma deve affrontarlo così tante volte. Il lato positivo è che è possibile con il linguaggio orientato agli oggetti Java mitigare quegli eventi indesiderati attraverso un concetto chiamato "Gestione delle eccezioni in Java ". Non ripara l'eccezione, ma fornisce un modo alternativo per gestirla.
Ci possono essere molte ragioni per il verificarsi di un'eccezione, tra cui l'immissione di dati errati, guasto hardware, errore di connessione, server inattivo, ecc. Pertanto, la gestione delle eccezioni è e sarà sempre importante nel corso dell'apprendimento di Java in quanto aiuta a garantire il normale flusso di un programma nel momento in cui si verifica un evento imprevisto. Ignorare le eccezioni può causare l'arresto anomalo dell'intero software e la perdita di dati.
Ora che abbiamo un'idea sulle eccezioni e sulla gestione delle eccezioni, analizziamola in dettaglio e capiamo anche come Java aiuta a gestire le eccezioni.
Leggi: Domande di intervista sulla gestione delle eccezioni
Sommario
Che cos'è la gestione delle eccezioni?
Uno sviluppatore può prevedere le eccezioni che un pezzo di codice può generare durante il runtime. Una delle cose più importanti su cui molti studenti diventano ambigui è che tutte le eccezioni si verificano durante il runtime e non al momento della compilazione. Java può gestire le eccezioni solo durante il runtime. Ci sono alcune parole chiave utilizzate in un programma java per creare un blocco del gestore di eccezioni.
java.lang.Exception è la classe padre di tutte le classi di eccezione. La classe Exception è una sottoclasse della classe Throwable incorporata che è una sottoclasse della classe Object . Oltre a Exception, Throwable ha anche un'altra classe, ovvero Error, che è una condizione anormale durante l'esecuzione del programma che non può essere gestita dai programmi Java che sono la principale differenza tra Error ed Exceptions.
Come mostrato nella figura sopra, ci sono principalmente due categorie di eccezioni in Java. Nella prossima sezione, daremo uno sguardo dettagliato ai tipi di eccezioni in Java.
Eccezioni Java
Le cause principali delle eccezioni sono quelle causate dal programmatore o da risorse fisiche che si sono guastate a causa di alcuni motivi. Sulla base di questi, ci sono principalmente due categorie di eccezioni in Java come di seguito vengono seguiti i dettagli:
- Eccezione controllata
- Eccezione non controllata
1. Eccezione selezionata
Le eccezioni controllate sono note come "eccezioni in fase di compilazione" poiché vengono controllate durante la compilazione dal compilatore per monitorare se l'eccezione viene gestita dal programmatore. Il sistema visualizza quindi un errore di compilazione.
Alcuni esempi di queste eccezioni sono IOException , Leggi: Idee per progetti Java per principianti
2. Eccezione non selezionata
Le eccezioni non selezionate sono chiamate "Eccezioni di runtime" poiché si verificano durante il runtime del programma. Le eccezioni deselezionate vengono normalmente ignorate durante la compilazione e non vengono controllate.
Esempi di queste eccezioni possono essere bug in un programma come errori logici o utilizzo di API errate che non sono sotto il controllo di un programmatore e richiedono la correzione di un amministratore di sistema.
Eccezione verificata e non verificata
| Punti di differenziazione | Eccezione selezionata Eccezione deselezionata Tempo di trattamento | Le eccezioni controllate vengono controllate e gestite al momento della compilazione. | Le eccezioni deselezionate non vengono controllate al momento della compilazione. |
| Identificazione dell'eccezione | Il programma fornisce un errore di compilazione se un metodo genera un'eccezione verificata. | Il programma viene compilato correttamente poiché il compilatore non può verificare l'eccezione. | |
| Eredità | Non ereditano la classe RuntimeException. | Sono le sottoclassi della classe RuntimeException. | |
| Ruolo dello sviluppatore | Può essere gestito dagli sviluppatori. | Non può essere gestito dagli sviluppatori. |
Comprendere le eccezioni è il passaggio principale prima di gestirle.
In che modo Java aiuta nella gestione delle eccezioni?
Ora che sappiamo che ci sono due tipi di eccezioni in Java, vale a dire, selezionate e deselezionate. Se un metodo sta generando un'eccezione verificata, dovrebbe essere gestita con un blocco try-catch o la parola chiave ' throws' dovrebbe essere dichiarata per evitare errori di compilazione in un programma.
Esempio di un'eccezione verificata:
Questo è un programma per leggere un file chiamato 'Java'. Esistono tre punti in cui viene generata un'eccezione verificata:
- FileInputStream: utilizzato per specificare il percorso e il nome del file genera FileNotFoundException .
- Il metodo read(): la lettura del contenuto del file genera IOException ;
iii. Il metodo close(): la chiusura del flusso di input del file genera IOException .
importa java.io.*;
classe Esempio {
public static void main( String args[])
{
FileInputStream fis = null ;
/*Il costruttore FileInputStream(File nomefile)
* genera un'eccezione verificata FileNotFoundException */
fis = nuovo FileInputStream ( "B:/java.txt" );
int k;
/* Metodo read() della classe FileInputStream genera
* un'eccezione verificata: IOException
*/
mentre (( k = fis.read() ) != – 1 )
{
Sistema . fuori . stampa (( carattere )k);
}
/*Il metodo close() chiude il flusso di input del file
* genera IOException*/
fis.close();
}
}
Output del programma di cui sopra:
Eccezione trovata nel thread "main" java.lang. Errore : problemi di compilazione irrisolti :
Eccezione non gestita trovata FileNotFoundException
Eccezione non gestita IOException trovata
Eccezione non gestita IOException trovata
Il motivo di questo errore di compilazione: mancata dichiarazione o gestione delle eccezioni.
Da leggere: Progetti Java GitHub
Metodi di gestione delle eccezioni
Esistono due modi per gestire le eccezioni descritte di seguito:
Metodo 1: dichiarazione della parola chiave dell'eccezione "throws".
Nel programma sopra, tutte e tre le eccezioni controllate sono all'interno del metodo main(). Pertanto, un modo per evitare l'errore di compilazione è dichiarare l'eccezione nel metodo utilizzando la parola chiave 'throws'. Poiché IOException è una classe padre di FileNotFoundException, coprirà anche questo.
Programma aggiornato utilizzando la parola chiave throws:
importa java.io.*;
classe Esempio {
public static void main( String args[]) genera IOException
{
FileInputStream fis = null ;
fis = nuovo FileInputStream ( "B:/java.txt" );
int k;
mentre (( k = fis.read() ) != – 1 )
{
Sistema . fuori . stampa (( carattere )k);
}
fis.close();
}
}
Produzione:
Visualizza il contenuto del file sullo schermo.
Metodo 2: gestisci le eccezioni utilizzando i blocchi try-catch.
Questo è un approccio più avanzato a quello sopra e una delle migliori pratiche di gestione delle eccezioni . Il codice del programma modificato, inclusi i blocchi try-catch, è il seguente:
importa java.io.*;
classe Esempio {
public static void main( String args[])
{
FileInputStream fis = null ;
prova {
fis = nuovo FileInputStream ( "B:/java.txt" );
} cattura ( FileNotFoundException fnfe){
Sistema . out .println( “Il file non è “ +
“presente al percorso indicato” );
}
int k;
prova {
mentre (( k = fis.read() ) != – 1 )
{
Sistema . fuori . stampa (( carattere )k);
}
fis.close();
} cattura ( IOException ioe){
Sistema . out .println( “Errore I/O “ +ioe);
}
}
}
Produzione:
Questo codice alla fine visualizzerà il contenuto del file.
Esempio di un'eccezione non controllata
Le eccezioni Unchecked non vengono controllate al momento della compilazione. Il programma non darà un errore di compilazione se non è dichiarato o gestito e funzionerà correttamente. Il compito dello sviluppatore è prevedere in anticipo le condizioni che potrebbero verificarsi causando tali eccezioni e gestirle. Tutte le eccezioni Unchecked sono sottoclassi della classe RuntimeException .
classe Esempio {
public static void main( String args[])
{
int num1= 10 ;
int num2= 0 ;
/*Divido qualsiasi numero per 0
* Getterà ArithmeticException
*/
int res=num1/num2;
Sistema . fuori .println(res);
}
}
Il codice verrà compilato correttamente con questo codice ma durante il runtime genererebbe ArithmeticException poiché le eccezioni non selezionate non vengono verificate in fase di compilazione. Diamo un'occhiata a un altro esempio.
classe Esempio {
public static void main( String args[])
{
int arr[] ={ 1 , 2 , 3 , 4 , 5 };
/* L'array ha 5 elementi ma lo vogliamo
* visualizza il valore dell'8° elemento. Getterà
* Indice della Matrice Fuori Dai Limiti d'Eccezione
*/
Sistema . out .println(arr[ 7 ]);
}
}
Questo codice verrà inoltre compilato correttamente poiché ArrayIndexOutOfBoundsException è un'eccezione non controllata.
Qui, per la gestione delle eccezioni non controllate, dovrebbe essere visualizzato un messaggio di eccezione all'utente che desidera visualizzare, ma non esiste nell'array.
Gestione dell'eccezione di codice precedente con il blocco try-catch
classe Esempio {
public static void main( String args[]) {
prova {
int arr[] ={ 1 , 2 , 3 , 4 , 5 };
Sistema . out .println(arr[ 7 ]);
}
cattura ( ArrayIndexOutOfBoundsException e){
Sistema . out .println( “L'indice specificato non esiste “ +
"nella matrice". );
}
}
}
Produzione:
L' indice specificato non esiste nella matrice.
Nota: all'interno di un blocco try possono essere presenti più blocchi catch per la gestione di eccezioni diverse.
Metodo 3 : utilizzo della parola chiave "finalmente".
A volte capita che un codice debba essere eseguito anche se si verifica un'eccezione. È qui che viene utilizzata la parola chiave finale . Ecco un codice tipico con la parola chiave 'finalmente'.
public int getPlayerScore(String playerFile)
genera FileNotFoundException {
Contenuto dello scanner = nullo;
Tentativo {
contenuto = nuovo Scanner ( nuovo File(playerFile));
return Integer.parseInt(contents.nextLine());
} finalmente {
if (contenuto != null ) {
content.close();
}
}
}
Qui, il blocco finale indica il codice che vogliamo che Java esegua durante il tentativo di leggere il file.
Anche se viene generata un'eccezione FileNotFoundException , Java chiamerà il contenuto difinally .
Possiamo gestire l'eccezione modificando il codice come di seguito:
public int PlayerScore(String playerRuns) {
Contenuto dello scanner;
Tentativo {
contenuto = nuovo Scanner(nuovo File(playerRuns));
return Integer.parseInt(contents.nextLine());
} cattura (FileNotFoundException noFile) {
logger.warn("File non trovato.");
restituire 0;
} finalmente {
Tentativo {
if (contenuto != nullo) {
content.close();
}
} cattura (IOException ioexc) {
logger.error("Impossibile chiudere il lettore.", ioexc);
}
}
}
Conclusione
Con questo articolo, abbiamo cercato di esaminare le nozioni di base su errori ed eccezioni e sulla gestione delle eccezioni in Java . Ci auguriamo che questa guida ti dia una buona idea di questa caratteristica unica che Java offre e che ora puoi gestire le eccezioni e recuperarle meglio. Conclusione
Java fornisce modi per gestire le eccezioni da quelle specifiche a quelle generiche. Le eccezioni che non possono essere previste facilmente in anticipo sono chiamate eccezioni non gestite. L'acquisizione di tutte le eccezioni offre visibilità al team di sviluppo sulla qualità del codice e sulle cause principali degli errori che possono essere risolti rapidamente.
Se sei interessato a saperne di più su Java, sullo sviluppo full stack, dai un'occhiata al diploma PG di upGrad e IIIT-B in sviluppo software full stack. È attentamente curato per i professionisti e assicura un supporto professionale a 360 gradi e include progetti dal vivo su cui lavorare. Entro la fine del corso, sarai in grado di progettare e creare applicazioni come Swiggy, IMDB, ecc.
Non sembra eccitante!-