Java prova a bloccare

Giava Tentativo block viene utilizzato per racchiudere il codice che potrebbe generare un'eccezione. Deve essere utilizzato all'interno del metodo.

Se si verifica un'eccezione in una particolare istruzione nel blocco try, il resto del codice del blocco non verrà eseguito. Pertanto, si consiglia di non mantenere il codice nel blocco try che non genererà un'eccezione.

Il blocco try Java deve essere seguito da catch o final block.

Sintassi di Java try-catch

 try{ //code that may throw an exception }catch(Exception_class_Name ref){} 

Sintassi di try-finally block

 try{ //code that may throw an exception }finally{} 

Blocco cattura Java

Il blocco catch Java viene utilizzato per gestire l'eccezione dichiarando il tipo di eccezione all'interno del parametro. L'eccezione dichiarata deve essere l'eccezione della classe genitore (ovvero, Eccezione) o il tipo di eccezione generata. Tuttavia, l'approccio corretto consiste nel dichiarare il tipo di eccezione generata.

file con estensione java

Il blocco catch deve essere utilizzato solo dopo il blocco try. È possibile utilizzare più blocchi catch con un singolo blocco try.

Funzionamento interno del blocco try-catch Java

La JVM controlla innanzitutto se l'eccezione viene gestita o meno. Se l'eccezione non viene gestita, JVM fornisce un gestore eccezioni predefinito che esegue le seguenti attività:

• Stampa la descrizione dell'eccezione.
• Stampa l'analisi dello stack (gerarchia dei metodi in cui si è verificata l'eccezione).
• Causa la chiusura del programma.

Ma se il programmatore dell'applicazione gestisce l'eccezione, viene mantenuto il normale flusso dell'applicazione, ovvero viene eseguito il resto del codice.

Problema senza gestione delle eccezioni

Cerchiamo di capire il problema se non utilizziamo un blocco try-catch.

Esempio 1

TryCatchExample1.java

 public class TryCatchExample1 { public static void main(String[] args) { int data=50/0; //may throw exception System.out.println('rest of the code'); } } 

Produzione:

 Exception in thread 'main' java.lang.ArithmeticException: / by zero 

Come mostrato nell'esempio sopra, il resto del codice non viene eseguito (in tal caso, il resto del codice la dichiarazione non viene stampata).

Potrebbero esserci 100 righe di codice dopo l'eccezione. Se l'eccezione non viene gestita, tutto il codice sotto l'eccezione non verrà eseguito.

Soluzione mediante gestione delle eccezioni

Vediamo la soluzione del problema precedente tramite un blocco java try-catch.

Esempio 2

TryCatchExample2.java

 public class TryCatchExample2 { public static void main(String[] args) { try { int data=50/0; //may throw exception } //handling the exception catch(ArithmeticException e) { System.out.println(e); } System.out.println('rest of the code'); } } 

Produzione:

 java.lang.ArithmeticException: / by zero rest of the code 

Come mostrato nell'esempio sopra, il resto del codice viene eseguito, cioè il resto del codice viene stampata la dichiarazione.

Esempio 3

In questo esempio, abbiamo mantenuto il codice anche in un blocco try che non genererà un'eccezione.

riga di comando di AutoCAD

ProvaCatchExample3.java

 public class TryCatchExample3 { public static void main(String[] args) { try { int data=50/0; //may throw exception // if exception occurs, the remaining statement will not exceute System.out.println('rest of the code'); } // handling the exception catch(ArithmeticException e) { System.out.println(e); } } } 

Produzione:

 java.lang.ArithmeticException: / by zero 

Qui possiamo vedere che se si verifica un'eccezione nel blocco try, il resto del codice del blocco non verrà eseguito.

Esempio 4

Qui gestiamo l'eccezione utilizzando l'eccezione della classe genitore.

TryCatchExample4.java

 public class TryCatchExample4 { public static void main(String[] args) { try { int data=50/0; //may throw exception } // handling the exception by using Exception class catch(Exception e) { System.out.println(e); } System.out.println('rest of the code'); } } 

Produzione:

 java.lang.ArithmeticException: / by zero rest of the code 

Esempio 5

Vediamo un esempio per stampare un messaggio personalizzato su eccezione.

ProvaCatchExample5.java

 public class TryCatchExample5 { public static void main(String[] args) { try { int data=50/0; //may throw exception } // handling the exception catch(Exception e) { // displaying the custom message System.out.println('Can't divided by zero'); } } } 

Produzione:

 Can't divided by zero 

Esempio 6

Vediamo un esempio per risolvere l'eccezione in un blocco catch.

TryCatchExample6.java

 public class TryCatchExample6 { public static void main(String[] args) { int i=50; int j=0; int data; try { data=i/j; //may throw exception } // handling the exception catch(Exception e) { // resolving the exception in catch block System.out.println(i/(j+2)); } } } 

Produzione:

 25 

Esempio 7

In questo esempio, insieme al blocco try, racchiudiamo anche il codice di eccezione in un blocco catch.

TryCatchExample7.java

 public class TryCatchExample7 { public static void main(String[] args) { try { int data1=50/0; //may throw exception } // handling the exception catch(Exception e) { // generating the exception in catch block int data2=50/0; //may throw exception } System.out.println('rest of the code'); } } 

Produzione:

 Exception in thread 'main' java.lang.ArithmeticException: / by zero 

Qui possiamo vedere che il blocco catch non conteneva il codice di eccezione. Quindi, racchiudi il codice dell'eccezione all'interno di un blocco try e utilizza il blocco catch solo per gestire le eccezioni.

Esempio 8

In questo esempio, gestiamo l'eccezione generata (Arithmetic Exception) con un diverso tipo di classe di eccezione (ArrayIndexOutOfBoundsException).

TryCatchExample8.java

 public class TryCatchExample8 { public static void main(String[] args) { try { int data=50/0; //may throw exception } // try to handle the ArithmeticException using ArrayIndexOutOfBoundsException catch(ArrayIndexOutOfBoundsException e) { System.out.println(e); } System.out.println('rest of the code'); } } 

Produzione:

 Exception in thread 'main' java.lang.ArithmeticException: / by zero 

Esempio 9

Vediamo un esempio per gestire un'altra eccezione non controllata.

TryCatchExample9.java

 public class TryCatchExample9 { public static void main(String[] args) { try { int arr[]= {1,3,5,7}; System.out.println(arr[10]); //may throw exception } // handling the array exception catch(ArrayIndexOutOfBoundsException e) { System.out.println(e); } System.out.println('rest of the code'); } } 

Produzione:

 java.lang.ArrayIndexOutOfBoundsException: 10 rest of the code 

Esempio 10

Vediamo un esempio per gestire l'eccezione verificata.

cambia Java

ProvaCatchExample10.java

 import java.io.FileNotFoundException; import java.io.PrintWriter; public class TryCatchExample10 { public static void main(String[] args) { PrintWriter pw; try { pw = new PrintWriter('jtp.txt'); //may throw exception pw.println('saved'); } // providing the checked exception handler catch (FileNotFoundException e) { System.out.println(e); } System.out.println('File saved successfully'); } } 

Produzione:

 File saved successfully