try catch finally
In questo tutorial, discuteremo di varie parole chiave utilizzate in Java per la gestione delle eccezioni come Try, Catch, Infine, Throw e Throw con esempi:
Nei nostri tutorial precedenti, abbiamo visto le basi della gestione delle eccezioni in Java insieme alle varie eccezioni supportate dalla classe Java Exception. Abbiamo anche discusso in dettaglio la NullPointerException.
Possiamo includere eccezioni nel nostro programma utilizzando determinate parole chiave fornite in Java. Queste parole chiave definiscono vari blocchi di codice che facilitano la definizione e la gestione delle eccezioni.
=> Visita qui per l'esclusiva serie di tutorial di formazione Java.
Cosa imparerai:
Prova, cattura, finalmente in Java
Le seguenti parole chiave vengono utilizzate in Java per la gestione delle eccezioni.
- Provare
- Catturare
- Infine
- Gettare
- Lancia
La tabella seguente descrive brevemente queste parole chiave.
| Parola chiave | Descrizione |
|---|---|
| Provare | Specifichiamo il blocco di codice che potrebbe dare origine all'eccezione in un blocco speciale con una parola chiave “Try”. |
| Catturare | Quando l'eccezione viene sollevata, deve essere rilevata dal programma. Questo viene fatto utilizzando una parola chiave 'catch'. Quindi un blocco catch segue il blocco try che solleva un'eccezione. La parola chiave catch dovrebbe sempre essere utilizzata con una prova. |
| Infine | A volte abbiamo un codice importante nel nostro programma che deve essere eseguito indipendentemente dal fatto che l'eccezione venga lanciata o meno. Questo codice viene inserito in un blocco speciale che inizia con la parola chiave 'Finalmente'. Il blocco Finalmente segue il blocco Try-catch. |
| Gettare | La parola chiave 'throw' viene utilizzata per generare esplicitamente l'eccezione. |
| Lancia | La parola chiave 'Throws' non genera un'eccezione ma viene utilizzata per dichiarare eccezioni. Questa parola chiave viene utilizzata per indicare che potrebbe verificarsi un'eccezione nel programma o nel metodo. |
In questo tutorial, discuteremo in dettaglio tutte le parole chiave di cui sopra insieme agli esempi di programmazione.
Prova Block In Java
Ogni volta che stiamo scrivendo un programma potrebbe esserci un codice che sospettiamo possa generare un'eccezione. Per esempio, potremmo sospettare che potrebbe esserci un'operazione di 'divisione per zero' nel codice che genererà un'eccezione.
Questo codice che potrebbe sollevare un'eccezione è racchiuso in un blocco con la parola chiave 'try'. Quindi il blocco try contiene il codice o la serie di istruzioni che possono sollevare un'eccezione.
La sintassi generale del blocco try è la seguente:
try{ //set of statements that can raise exception } Quindi, se un programmatore pensa che certe istruzioni solleveranno eccezioni, racchiudete queste istruzioni in un blocco try. Si noti che quando si verifica un'eccezione in un'istruzione specifica in un blocco try, il resto del codice non viene eseguito.
Quando si verifica un'eccezione in un blocco try in una determinata istruzione, il controllo esce e il programma termina bruscamente. Per evitare questa interruzione improvvisa del programma, dovremmo 'gestire' questa eccezione. Questa gestione viene eseguita utilizzando la parola chiave 'catch'. Quindi un blocco try ha sempre un blocco catch che lo segue.
Cattura il blocco in Java
Usiamo un blocco catch per gestire le eccezioni. Questo è il blocco con la parola chiave 'catch'. Il blocco catch segue il blocco try.
Ogni volta che si verifica un'eccezione nel blocco try, viene eseguito il codice nel blocco catch che corrisponde all'eccezione.
La sintassi generale del blocco catch è:
catch (Exception e){ //code to handle exception e }In genere, l'eccezione dichiarata deve essere la classe genitore di tutte le eccezioni, ad esempio Eccezione. Ma se è presente più di un'eccezione, possiamo anche scrivere tipi di eccezione specifici o eccezioni generate.
Successivamente, discuteremo del blocco try-catch. Nota che per ogni blocco try, possiamo avere più blocchi catch.
Try-Catch Java
La sintassi generale del blocco try-catch è mostrata di seguito:
try{ //code causing exception } catch (exception (exception_type) e (object)) { //exception handling code }Il blocco try può avere più righe di codice che possono sollevare più eccezioni. Ciascuna di queste eccezioni viene gestita da un blocco catch indipendente.
Il gestore di eccezioni generico, oggetto e della classe Exception può gestire tutte le eccezioni, ma se vogliamo gestire eccezioni specifiche, è consigliabile specificare il gestore di eccezioni generico come ultimo blocco di cattura.
Java Prova un esempio di cattura
Ora dimostriamo un blocco try-catch in Java. Qui nel blocco try, definiamo un'operazione di divisione. Il divisore è zero. Quindi l'affermazione che divide i due numeri solleva un'eccezione aritmetica. Abbiamo un blocco catch che definisce un gestore per l'eccezione aritmetica.
Di seguito è riportato un esempio di programma Java.
class Main { public static void main(String args()) { int val1, val2; try { //this block will contain statements that may raise exceptions System.out.println('Try Block:: Start'); val1 = 0; val2 = 25 / val1; System.out.println(val2); System.out.println('Try Block:: End'); } catch (ArithmeticException e) { //handler for ArithmeticException System.out.println('ArithmeticException :: Divide by Zero!!'); } System.out.println('Outside try-catch:: Rest of the code.'); } } Produzione
domande di colloquio per tester qa entry level
Cattura di più eccezioni
Come già accennato, un blocco try può contenere un codice che solleva più di un'eccezione. In questo caso, avremo bisogno di più di un blocco catch per gestire ogni eccezione. Un singolo blocco try può essere seguito da più blocchi catch. Ogni blocco catch gestirà le eccezioni indipendenti.
Nel caso di più blocchi di cattura, dobbiamo ricordare i seguenti punti:
- In un programma Java, in qualsiasi momento, può verificarsi solo un'eccezione. Inoltre, in qualsiasi momento, viene eseguito un solo blocco catch.
- I blocchi multipli di cattura dovrebbero essere ordinati in modo tale che il blocco di cattura per l'eccezione più specifica dovrebbe venire prima e poi il generale.
Per esempio, se abbiamo ArithmeticException e general Exception, allora il blocco catch che gestisce ArithmeticException verrà per primo seguito dall'eccezione di gestione del blocco catch.
L'esempio seguente mostra più blocchi catch.
public class Main { public static void main(String() args) { //try block containing exception prone code try{ System.out.println('try Block:: Begin'); int myArray()=new int(5); myArray (5)=10/0; } //multiple catch blocks catch(ArithmeticException e) { System.out.println('Arithmetic Exception :: Divide by zero!!'); } catch(ArrayIndexOutOfBoundsException e) { System.out.println('ArrayIndexOutOfBounds :: Accessed index out of bounds'); } catch(Exception e) { System.out.println('Exception :: ' + e.getMessage ()); } System.out.println('rest of the code'); } } Produzione
Nel programma precedente, viene generata un'eccezione ArithmeticException che viene catturata nel primo blocco catch. Se questo blocco catch non è stato specificato, l'eccezione si sarebbe propagata al blocco catch generalizzato.
Modifichiamo leggermente il programma precedente in modo che il blocco try sollevi due eccezioni. Vediamo ora l'output.
public class Main { public static void main(String() args) { //try block containing exception prone code try{ System.out.println('try Block:: Begin'); int myArray()=new int(5); System.out.println('Array element 10 : ' + myArray(10)); myArray(5)=10/0; } //multiple catch blocks catch(ArithmeticException e) { System.out.println('Arithmetic Exception :: Divide by zero!!'); } catch(ArrayIndexOutOfBoundsException e) { System.out.println('ArrayIndexOutOfBounds :: Accessed index out of bounds'); } catch(Exception e) { System.out.println('Exception :: ' + e.getMessage ()); } System.out.println('rest of the code'); } } Produzione
Se vediamo questo output, mostra la generazione di ArrayIndexOutOfBoundsException. Questo perché l'istruzione che genera ArrayIndexOutOfBoundsException viene eseguita per prima. L'eccezione viene generata e il controllo passa al blocco catch corrispondente.
Try-Catch annidato
Un blocco try all'interno di un altro blocco try è chiamato blocco try annidato. Abbiamo bisogno di tali strutture in certe situazioni quando un pezzo di codice contenuto in un codice try può essere tale che alcune righe sollevano certe eccezioni e un altro pezzo di codice solleva un'eccezione completamente diversa.
In caso di blocchi try annidati, prima viene eseguito il blocco try più interno e viene gestita l'eccezione. Se il blocco try più interno non ha un blocco catch corrispondente, viene propagato di un livello fino al blocco try padre. In questo modo l'eccezione viene propagata verso l'alto finché non viene trovato il gestore di eccezioni corrispondente.
Se non è presente alcun gestore di eccezioni che corrisponde all'eccezione, il programma viene interrotto bruscamente con un messaggio generato dal sistema.
Di seguito viene fornita la sintassi generale di un blocco try annidato:
try { //try_block 1; try { //try_block 2; } catch(Exception e) { //exception handler code } } catch(Exception e) { //exception handler code }Implementiamo un programma per dimostrare il blocco try-catch annidato.
class Main{ public static void main(String args()){ //Main try block try{ //try block1 try{ System.out.println('Try Block1'); int num =15/0; System.out.println(num); } catch(ArithmeticException e1){ System.out.println('Block1 Exception: e1'); } //try block2 try{ System.out.println('Try Block2'); int num =100/0; System.out.println(num); } catch(ArrayIndexOutOfBoundsException e2){ System.out.println('Block2 Exception: e2'); } System.out.println('General statement after Block1 and Block2'); } catch(ArithmeticException e3){ System.out.println('Main Block Arithmetic Exception'); } catch(ArrayIndexOutOfBoundsException e4){ System.out.println('Main Block ArrayIndexOutOfBoundsException'); } catch(Exception e5){ System.out.println('Main Block General Exception'); } System.out.println('Code after Nested Try Block'); } } Produzione
Nel programma sopra, abbiamo due blocchi try racchiusi nel blocco try principale. Entrambi i blocchi try interni hanno un codice che solleva ArithmeticException. Ma abbiamo fornito un blocco catch corrispondente solo per il primo blocco e non per il secondo blocco try.
Quindi il secondo blocco propaga la sua eccezione al blocco try principale e quindi la gestisce. Questo è evidente dall'output.
Infine Block In Java
Finora abbiamo visto il blocco try-catch e try annidato. Sappiamo che il codice che dovrebbe sollevare l'eccezione viene inserito in un blocco try. Quando si verifica un'eccezione, il resto del codice nel blocco try non viene eseguito.
Il programma termina improvvisamente se un'eccezione non viene gestita o il controllo viene passato al gestore delle eccezioni.
In una tale situazione, sorge la necessità di includere un codice che deve essere eseguito indipendentemente dal fatto che si verifichi o meno un'eccezione. Ciò significa che eseguiremo un pezzo di codice anche quando si verifica un'eccezione e anche quando l'eccezione non si verifica.
Ma poiché il blocco try esce dopo che è stata sollevata l'eccezione, non possiamo inserire questo codice nel blocco try. Allo stesso modo, il blocco catch ha un gestore di eccezioni, quindi non possiamo metterlo anche nel blocco catch.
Quindi abbiamo bisogno di un blocco separato che contenga un codice che venga eseguito indipendentemente dal fatto che si verifichi o meno un'eccezione. Java fornisce un blocco 'finalmente' che contiene questo pezzo di codice.
Quindi un blocco finalmente in Java può contenere istruzioni critiche che devono essere eseguite nel programma. L'esecuzione di queste istruzioni dovrebbe essere eseguita anche quando si verifica o meno un'eccezione.
Pertanto, inseriremo codice come la chiusura di connessioni, oggetti stream, ecc. O qualsiasi codice di pulizia nel blocco finalmente in modo che possano essere eseguiti anche se si verifica un'eccezione.
download gratuito del software per scaricare video da YouTube
Il blocco finalmente in Java viene solitamente inserito dopo un blocco try o catch. Nota che il blocco finalmente non può esistere senza un blocco try. Quando il blocco finale viene incluso con try-catch, diventa un ' prova a catturare finalmente 'Blocco.
Possiamo saltare il blocco alla fine nel codice di gestione delle eccezioni. Ciò significa che finalmente il blocco è facoltativo.
Se il blocco try non solleva alcuna eccezione, il blocco finalmente verrà eseguito dopo il blocco try. Se c'è un'eccezione nel blocco try, il controllo passerà prima al blocco catch e poi al blocco finalmente.
Un'eccezione che si verifica nel blocco finalmente si comporta allo stesso modo di qualsiasi altra eccezione. Anche se il blocco try contiene un'istruzione return o istruzioni di ramificazione come break e continue, il blocco finalmente verrà comunque eseguito.
Tenendo a mente questi punti, andiamo avanti con la sintassi generale e gli esempi di finalmente block.
La sintassi generale del blocco finalmente è la seguente:
try { //code that might raise exception }catch { //code that handles exception }finally { //mandatory code to be executed }Sebbene alla fine il blocco venga sempre eseguito, ci sono alcune situazioni o casi in cui non viene eseguito.
Questi sono i seguenti casi:
- Quando il filo è morto.
- Quando viene utilizzato il metodo System.exit ().
- Quando si verifica un'eccezione nel blocco finalmente.
Implementiamo un paio di programmi per dimostrare il blocco finale.
class Main { public static void main (String args()) { //try block try { System.out.println ('::Try Block::'); int data = 125 / 5; System.out.println ('Result:' + data); } //catch block catch (NullPointerException e) { System.out.println ('::Catch Block::'); System.out.println (e); } //finally block finally { System.out.println (':: Finally Block::'); System.out.println ('No Exception::finally block executed'); } System.out.println ('rest of the code...'); } } Produzione
Il programma sopra mostra un blocco try-catch-latest. Nel blocco try viene eseguita un'operazione valida e quindi non viene generata alcuna eccezione. Pertanto, il controllo non viene passato per catturare da try ma per bloccare infine.
Il programma seguente è un altro esempio di blocco try-catch-latest ma in questo caso, l'eccezione viene lanciata nel blocco try mentre eseguiamo un'operazione di divisione per zero. Quindi il blocco finalmente viene eseguito dopo che il blocco try è stato eseguito.
class Main { public static void main(String args()) { //try block try{ System.out.println('::Try block::'); int num=67/0; System.out.println(num); } //catch block catch(ArithmeticException e){ System.out.println('::Catch block::'); System.out.println('ArithmeticException::Number divided by zero'); } //finally block finally{ System.out.println('::Finally block::'); } System.out.println('Rest of the code continues...'); } } Produzione
Lancia un'eccezione in Java
Java fornisce una parola chiave 'throw' utilizzando la quale possiamo lanciare esplicitamente le eccezioni nel codice. Per esempio, se stiamo controllando operazioni aritmetiche e vogliamo sollevare alcune eccezioni dopo aver controllato gli operandi, possiamo farlo usando la parola chiave 'throw'.
Usando la parola chiave throw, possiamo lanciare le eccezioni selezionate o deselezionate. La parola chiave throw viene utilizzata anche per generare eccezioni personalizzate.
La sintassi generale della parola chiave throw è:
throw exception; or throw new exception_class('error message'); Di seguito è riportato un programma di esempio per dimostrare la parola chiave throw.
public class Main{ static void validate_Age(int age){ //if specified age is <18, throw ArithmeticException if(age<18) throw new ArithmeticException('Not eligible to vote and drive!!'); else //print the message System.out.println('Eligible to vote and drive!!'); } public static void main(String args()){ //call validate_Age method validate_Age(10); System.out.println('rest of the code...'); } } Produzione
Nel programma sopra, utilizziamo un metodo per convalidare l'età. Se l'età è<18, then an exception is thrown to indicate the age is not valid.
Getta clausola
Abbiamo visto try block per dichiarare eccezioni. Contiene il codice che può sollevare eccezioni. C'è un altro modo per dichiarare un'eccezione e sta usando la parola chiave 'throws'.
La dichiarazione di eccezione utilizzando la parola chiave 'throws' dice al programmatore che potrebbe esserci un'eccezione specificata dopo la parola chiave 'throws' e il programmatore dovrebbe fornire il codice gestore corrispondente per questa eccezione per mantenere il normale flusso del programma.
Tuttavia, sorge la domanda sul motivo per cui abbiamo bisogno di una parola chiave 'throws' quando abbiamo un blocco try-catch più affidabile per dichiarare e gestire le eccezioni?
Uno dei motivi è che poiché il numero di eccezioni che potrebbero verificarsi aumenta, aumenta anche il numero di blocchi catch che gestiscono le eccezioni poiché un blocco catch può gestire solo un'eccezione.
Allo stesso modo, se ci sono molti metodi in un programma e ogni metodo ha numerose eccezioni, il codice diventerà inutilmente lungo e ingestibile.
Pertanto, dichiarare un'eccezione con la parola chiave throws nella firma del metodo e quindi gestire la chiamata al metodo utilizzando try-catch sembra essere una soluzione praticabile.
Un altro vantaggio di dichiarare eccezioni usando la parola chiave throws è che siamo costretti a gestire le eccezioni. Se non forniamo un gestore per un'eccezione dichiarata, il programma solleverà un errore.
La sintassi generale della parola chiave throws è la seguente:
return_type method_name() throws exception_class_name{ //method code } Implementiamo ora un programma Java per dimostrare la parola chiave 'throws'.
In questo programma, abbiamo una classe Example_throw in cui abbiamo un metodo testMethod. Nella firma di questo testMethod, dichiariamo due eccezioni IOException e Arithmetic Exception utilizzando la parola chiave throws. Quindi, nella funzione principale, le eccezioni lanciate vengono gestite dal blocco catch.
import java.io.*; class Example_Throw { //declare exception using throws in the method signature void testMethod(int num) throws IOException, ArithmeticException{ if(num==1) throw new IOException('IOException Occurred'); else throw new ArithmeticException('ArithmeticException'); } }class Main{ public static void main(String args()){ try{ //this try block calls the above method so handle the exception Example_Throw obj=new Example_Throw(); obj.testMethod(1); }catch(Exception ex){ System.out.println(ex); } } }Produzione
Domande frequenti
Q # 1) Quando utilizzare i lanci lancio VS tentativo di cattura in Java?
Risposta: La parola chiave 'throws' viene utilizzata per dichiarare l'eccezione con la firma del metodo. La parola chiave throw viene utilizzata per generare esplicitamente l'eccezione. Il blocco try-catch viene utilizzato per gestire le eccezioni lanciate da altri.
D # 2) Possiamo usare lanci, provare e catturare in un unico metodo?
Risposta: No. Non puoi lanciare l'eccezione e anche catturarla con lo stesso metodo. L'eccezione dichiarata utilizzando throws deve essere gestita nel metodo chiamante che chiama il metodo che ha generato l'eccezione.
D # 3) Cosa succede quando un blocco catch genera un'eccezione?
Risposta: Quando viene generata un'eccezione nel blocco catch, il programma interromperà l'esecuzione. Nel caso in cui il programma debba continuare, ci deve essere un blocco try-catch separato per gestire l'eccezione sollevata nel blocco catch.
D # 4) Cos'è try-catch-finalmente in Java?
Risposta: Il blocco try-catch-latest contiene i tre blocchi, ovvero try block, catch block e infine block.
Il blocco Try contiene il codice che potrebbe generare un'eccezione. Il blocco Catch contiene il gestore delle eccezioni per le eccezioni nel blocco try. Il blocco finalmente contiene il codice critico che verrà eseguito indipendentemente dal fatto che si sia verificata o meno l'eccezione.
Q # 5) Può finalmente bloccare avere try-catch?
Risposta: Sì, se abbiamo un codice di pulizia che potrebbe generare un'eccezione nel blocco finalmente, allora possiamo avere un blocco try-catch. Tuttavia, sembra brutto.
Conclusione
In questo tutorial, abbiamo discusso le varie parole chiave utilizzate nella gestione delle eccezioni in Java. Abbiamo discusso le parole chiave come provare, prendere, infine, lanciare e lanciare.
Il codice che potrebbe generare un'eccezione è racchiuso nel blocco try e catch fornisce il gestore per l'eccezione. Il blocco finalmente esegue il codice racchiuso in esso indipendentemente dal fatto che l'eccezione venga generata o meno. Il blocco finalmente segue generalmente il blocco try o try-catch.
Usiamo la parola chiave throws per dichiarare eccezioni con la firma del metodo e throw viene utilizzata esplicitamente per generare eccezioni. Di solito usiamo la parola chiave throw per generare eccezioni personalizzate.
=> Dai un'occhiata alla guida di formazione Java perfetta qui.
Lettura consigliata
- Eccezioni Java e gestione delle eccezioni con esempi
- Come gestire l'eccezione ArrayIndexOutOfBoundsException in Java?
- Tutorial JAVA per principianti: oltre 100 tutorial video Java pratici
- Gestione delle eccezioni JDBC - Come gestire le eccezioni SQL
- Esercitazione sulla gestione delle eccezioni C # con esempi di codice
- Guida completa alla gestione delle eccezioni PL SQL con esempi
- Gestione delle eccezioni in C ++
- Python Try Except - Python Handling Eccezione con esempi