TechCodeview

Java try blokk

Jáva próbáld ki blokkot arra használják, hogy bezárják azt a kódot, amely kivételt okozhat. A módszeren belül kell használni.

Ha kivétel történik az adott utasításnál a try blokkban, a blokkkód többi része nem hajtódik végre. Ezért nem ajánlott a kódot a try blokkban tartani, amely nem okoz kivételt.

A Java try blokkot vagy a catch-nek vagy a végül blokknak kell követnie.

A Java try-catch szintaxisa

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

A try-finally blokk szintaxisa

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

Java catch blokk

A Java catch blokk a kivétel kezelésére szolgál a kivétel típusának a paraméteren belüli deklarálásával. A deklarált kivételnek a szülő osztály kivételének (azaz kivételnek) vagy a generált kivételtípusnak kell lennie. A jó megközelítés azonban a generált kivételtípus deklarálása.

gimp mentés jpeg formátumban

A catch blokkot csak a try blokk után szabad használni. Több fogási blokkot is használhat egyetlen próbálkozási blokkal.

Java try-catch blokk belső működése

A JVM először ellenőrzi, hogy a kivételt kezelték-e vagy sem. Ha a kivétel nincs kezelve, a JVM alapértelmezett kivételkezelőt biztosít, amely a következő feladatokat hajtja végre:

• Kinyomtatja a kivétel leírását.
• Kinyomtatja a verem nyomkövetését (a kivétel előfordulásának módszereinek hierarchiája).
• A program leállását okozza.

De ha az alkalmazásprogramozó kezeli a kivételt, akkor az alkalmazás normál áramlása megmarad, azaz a kód többi része végrehajtódik.

Kivétel nélküli kezelési probléma

Próbáljuk megérteni a problémát, ha nem használunk try-catch blokkot.

1. példa

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'); } } 

Kimenet:

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

Ahogy a fenti példában is látható, a a kód többi része nem hajtják végre (ilyen esetben a a kód többi része nyilatkozat nincs nyomtatva).

A kivétel után 100 sornyi kód lehet. Ha a kivételt nem kezelik, a kivétel alatti összes kód nem kerül végrehajtásra.

Megoldás kivételkezeléssel

Nézzük meg a fenti probléma megoldását egy java try-catch blokk segítségével.

2. példa

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'); } } 

Kimenet:

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

Ahogy a fenti példában is látható, a a kód többi része végrehajtják, azaz a a kód többi része nyilatkozatot nyomtatnak.

3. példa

Ebben a példában a kódot egy try blokkban is megtartottuk, amely nem dob kivételt.

TryCatchExample3.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); } } } 

Kimenet:

javatható

 java.lang.ArithmeticException: / by zero 

Itt láthatjuk, hogy ha kivétel történik a try blokkban, a blokkkód többi része nem hajtódik végre.

4. példa

Itt a kivételt a szülő osztály kivételével kezeljük.

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'); } } 

Kimenet:

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

5. példa

Lássunk egy példát egyéni üzenet nyomtatására kivétel esetén.

TryCatchExample5.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'); } } } 

Kimenet:

 Can't divided by zero 

6. példa

Nézzünk egy példát a kivétel feloldására egy catch blokkban.

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)); } } } 

Kimenet:

 25 

7. példa

Ebben a példában a try blokk mellett kivételkódot is befoglalunk egy catch blokkba.

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'); } } 

Kimenet:

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

Itt láthatjuk, hogy a catch blokk nem tartalmazta a kivételkódot. Tehát zárja be a kivételkódot egy try blokkba, és csak a catch blokkot használja a kivételek kezelésére.

8. példa

Ebben a példában a generált kivételt (Arithmetic Exception) egy másik típusú kivételosztállyal kezeljük (ArrayIndexOutOfBoundsException).

c++ hasító karakterlánc

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'); } } 

Kimenet:

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

9. példa

Lássunk egy példát egy másik ellenőrizetlen kivétel kezelésére.

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'); } } 

Kimenet:

 java.lang.ArrayIndexOutOfBoundsException: 10 rest of the code 

10. példa

Nézzünk egy példát az ellenőrzött kivételek kezelésére.

TryCatchExample10.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'); } } 

Kimenet:

 File saved successfully