try catch finally
V tomto výučbe sa budeme zaoberať rôznymi kľúčovými slovami používanými v prostredí Java na spracovanie výnimiek, ako sú Try, Catch, Finally, Throw a Throws s príkladmi:
V našich predchádzajúcich tutoriáloch sme videli základy spracovania výnimiek v Jave spolu s rôznymi výnimkami podporovanými triedou Java Exception. Podrobne sme tiež diskutovali o výnimke NullPointerException.
Do nášho programu môžeme zahrnúť výnimky pomocou určitých kľúčových slov, ktoré sú poskytované v jazyku Java. Tieto kľúčové slová definujú rôzne bloky kódu, ktoré uľahčujú definovanie a spracovanie výnimiek.
=> Navštívte tu sériu exkluzívnych výukových programov Java.
Čo sa dozviete:
Skúste, chyťte, konečne v Jave
Nasledujúce kľúčové slová sa používajú v prostredí Java na spracovanie výnimiek.
- Vyskúšajte
- Chytiť
- Nakoniec
- Hoď
- Vrhá
Nasledujúca tabuľka stručne popisuje tieto kľúčové slová.
| Kľúčové slovo | Popis |
|---|---|
| Vyskúšajte | Blok kódu, z ktorého by mohla vzniknúť výnimka, určíme v špeciálnom bloku s kľúčovým slovom „Vyskúšať“. |
| Chytiť | Keď sa vyvolá výnimka, musí ju zachytiť program. To sa deje pomocou kľúčového slova „catch“. Blok úlovkov nasleduje za blokom try, ktorý vyvoláva výnimku. Kľúčové slovo catch by sa malo vždy použiť pri pokuse. |
| Nakoniec | Niekedy máme v našom programe dôležitý kód, ktorý je potrebné vykonať bez ohľadu na to, či je alebo nie je vyvolaná výnimka. Tento kód je umiestnený v špeciálnom bloku začínajúcom kľúčovým slovom „Konečne“. Blok nakoniec nasleduje za blokom Try-catch. |
| Hoď | Kľúčové slovo „throw“ sa používa na výslovné vyvolanie výnimky. |
| Vrhá | Kľúčové slovo „Hodí“ nevyvoláva výnimku, ale používa sa na jej vyhlásenie. Toto kľúčové slovo sa používa na označenie toho, že v programe alebo metóde môže dôjsť k výnimke. |
V tomto výučbe sa podrobne zaoberáme všetkými vyššie uvedenými kľúčovými slovami spolu s príkladmi programovania.
Vyskúšajte Block In Java
Kedykoľvek píšeme program, môže sa vyskytnúť kód, o ktorom sa domnievame, že by mohol spôsobiť výnimku. Napríklad, mohli by sme mať podozrenie, že v kóde môže byť operácia „delenia nulou“, ktorá spôsobí výnimku.
Tento kód, ktorý by mohol vyvolať výnimku, je uzavretý v bloku s kľúčovým slovom „try“. Blok try obsahuje kód alebo skupinu príkazov, ktoré môžu vyvolať výnimku.
Všeobecná syntax bloku try je nasledovná:
try{ //set of statements that can raise exception } Ak si teda programátor myslí, že určité výroky spôsobia výnimky, uzavrite ich do bloku try. Všimnite si, že keď dôjde k výnimke pri konkrétnom príkaze v bloku try, zvyšok kódu sa nespustí.
Ak sa vyskytne výnimka v bloku try pri konkrétnom príkaze, potom vyjde ovládací prvok a program sa náhle ukončí. Aby sme zabránili tomuto náhlemu ukončeniu programu, mali by sme túto výnimku „vybaviť“. Táto manipulácia sa vykonáva pomocou kľúčového slova „catch“. Takže blok blokovania má za sebou vždy blok blokovania.
Chytiť blok v Jave
Na spracovanie výnimiek používame blok chytania. Toto je blok s kľúčovým slovom „catch“. Blok úlovkov nasleduje za blokom try.
Kedykoľvek dôjde k výnimke v bloku try, vykoná sa kód v bloku catch, ktorý zodpovedá výnimke.
Všeobecná syntax bloku catch je:
catch (Exception e){ //code to handle exception e }Všeobecne platí, že deklarovaná výnimka musí byť nadradenou triedou všetkých výnimiek, t. J. Výnimka. Pokiaľ ale existuje viac ako jedna výnimka, môžeme napísať aj konkrétne typy výnimiek alebo vygenerované výnimky.
Ďalej si rozoberieme blok try-catch. Upozorňujeme, že pre každý blok pokusu môžeme mať viac blokov úlovku.
Try-Catch Java
Všeobecná syntax bloku try-catch je uvedená nižšie:
try{ //code causing exception } catch (exception (exception_type) e (object)) { //exception handling code }Blok try môže mať viac riadkov kódu, vďaka ktorým môže dôjsť k viacerým výnimkám. Každá z týchto výnimiek je spracovaná nezávislým blokom catch.
Obecný obslužný program výnimiek, objekt e triedy Exception, dokáže spracovať všetky výnimky, ale ak chceme spracovať konkrétne výnimky, je vhodné určiť obslužný program všeobecnej výnimky ako posledný blok úlovku.
Java Vyskúšajte príklad chytenia
Teraz si ukážeme blok try-catch v Jave. Tu v bloku try definujeme operáciu delenia. Deliteľ je nula. Výrok, ktorý rozdeľuje tieto dve čísla, teda vyvoláva aritmetickú výnimku. Máme blok úlovkov, ktorý definuje obslužnú rutinu pre aritmetickú výnimku.
Nižšie je uvedený príklad programu 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.'); } } Výkon
najlepšie miesta na pozeranie anime online zadarmo
Zachytenie viacerých výnimiek
Ako už bolo spomenuté, blok try môže obsahovať kód, ktorý vyvolá viac ako jednu výnimku. V takom prípade budeme na zvládnutie každej výnimky potrebovať viac ako jeden blok zachytenia. Za jedným blokom pokusu môžu nasledovať viaceré bloky úlovkov. Každý blok úlovku spracuje nezávislé výnimky.
V prípade viacerých blokov úlovku si musíme pamätať nasledujúce body:
- V programe Java sa môže kedykoľvek vyskytnúť iba jedna výnimka. Taktiež sa kedykoľvek vykoná iba jeden blok zachytenia.
- Viacero blokov úlovku by malo byť usporiadaných tak, aby najskôr prišiel blok úlovkov pre najšpecifickejšiu výnimku a až potom všeobecný.
Napríklad, Ak máme ArithmeticException a General Exception, potom najskôr príde na rad blokovanie úlovkov ArithmeticException a potom Exception blokovanie úlovkov.
Nasledujúci príklad demonštruje viac blokov úlovku.
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'); } } Výkon
Vo vyššie uvedenom programe sa vyvolá ArithmeticException zachytená v prvom bloku zachytenia. Ak by tento blok úlovkov nebol zadaný, potom by sa výnimka rozšírila na zovšeobecnený blok úlovkov.
Poďme mierne upraviť vyššie uvedený program tak, aby blok try vyvolal dve výnimky. Teraz si pozrime výstup.
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'); } } Výkon
Ak vidíme tento výstup, ukazuje vyhodenie ArrayIndexOutOfBoundsException. Je to preto, lebo najskôr sa vykoná príkaz, ktorý vyvoláva ArrayIndexOutOfBoundsException. Výnimka je vyvolaná a ovládací prvok prejde do príslušného bloku catch.
Vnorené Try-Catch
Blok try v inom bloku try sa nazýva vnorený blok try. Takéto štruktúry potrebujeme v určitých situáciách, keď časť kódu obsiahnutá v try kóde môže byť taká, že niektoré riadky vyvolávajú určité výnimky a iná časť kódu vyvoláva úplne inú výnimku.
V prípade vnorených blokov try sa najskôr vykoná najvnútornejší blok try a spracuje sa výnimka. Ak najvnútornejší pokusný blok nemá zodpovedajúci úlovkový blok, potom sa rozšíri o jednu úroveň vyššie až k jeho nadradenému pokusnému bloku. Týmto spôsobom sa výnimka šíri nahor, kým sa nenájde zodpovedajúci obslužný program výnimiek.
Ak s touto výnimkou nie je žiadny obslužný program výnimky, program sa náhle ukončí správou vygenerovanou systémom.
Všeobecná syntax vnoreného bloku try je uvedená nižšie:
try { //try_block 1; try { //try_block 2; } catch(Exception e) { //exception handler code } } catch(Exception e) { //exception handler code }Poďme implementovať program na demonštráciu vnoreného bloku try-catch.
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'); } } Výkon
Vo vyššie uvedenom programe máme v hlavnom bloku try dva uzavreté bloky try. Oba vnútorné bloky try majú kód, ktorý vyvoláva ArithmeticException. Ale poskytli sme zodpovedajúci úlovkový blok iba pre prvý blok a nie pre druhý blok pokusu.
Preto druhý blok šíri svoju výnimku na hlavný blok try a potom s ňou narába. Je to zrejmé z výstupu.
Nakoniec zablokujte v Jave
Doteraz sme videli blok try-catch a nested try. Vieme, že kód, od ktorého sa očakáva zvýšenie výnimky, sa vloží do bloku try. Ak dôjde k výnimke, zvyšok kódu v bloku try sa nevykoná.
Program sa náhle ukončí, ak sa nespracuje výnimka, alebo sa ovládací prvok odovzdá obsluhe výnimky.
V takejto situácii vzniká potreba zahrnúť kód, ktorý sa má vykonať bez ohľadu na to, či dôjde k výnimke alebo nie. To znamená, že vykonáme časť kódu, aj keď dôjde k výnimke a tiež vtedy, keď sa výnimka nevyskytne.
Ale keď sa try blok ukončí po vyvolaní výnimky, nemôžeme tento kód vložiť do bloku try. Podobne má blok zachytávania výnimku, takže ho nemôžeme vložiť ani do bloku zachytenia.
Potrebujeme teda samostatný blok, ktorý obsahuje kód, ktorý sa vykoná bez ohľadu na to, či dôjde k výnimke alebo nie. Java poskytuje blok „konečne“, ktorý obsahuje túto časť kódu.
Preto konečne blok v Jave môže obsahovať kritické príkazy, ktoré sa majú vykonať v programe. Vykonanie týchto vyhlásení by sa malo vykonať, aj keď dôjde k výnimke alebo nie.
Preto vložíme kód ako ukončovacie spojenia, streamované objekty atď. Alebo akýkoľvek čistiaci kód do konečne bloku, aby ich bolo možné vykonať, aj keď dôjde k výnimke.
Konečný blok v Jave sa zvyčajne umiestni po bloku try alebo catch. Upozorňujeme, že blok konečne nemôže existovať bez bloku try. Keď je blok konečne zahrnutý v try-catch, stane sa „ skúste-chytiť-konečne ”Blok.
Blok nakoniec môžeme preskočiť v kóde na spracovanie výnimiek. To znamená, že konečne blok je voliteľný.
Ak blok try nezvýši žiadnu výnimku, blok konečne sa vykoná po bloku try. Ak v bloku try existuje výnimka, potom kontrola najskôr prejde do bloku catch a potom do bloku final.
Výnimka vyskytujúca sa v konečne bloku sa chová rovnako ako akákoľvek iná výnimka. Aj keď blok try obsahuje príkazy na návrat alebo vetviace príkazy ako break and continue, potom bude blok konečne vykonaný.
Ak budete mať na pamäti tieto body, pokračujeme všeobecnou syntaxou a príkladmi konečne zablokovaného.
Všeobecná syntax bloku konečne je nasledovná:
try { //code that might raise exception }catch { //code that handles exception }finally { //mandatory code to be executed }Aj keď sa blok nakoniec vykoná vždy, existujú určité situácie alebo prípady, keď sa nevykoná.
Toto sú nasledujúce prípady:
- Keď je vlákno mŕtve.
- Keď sa používa metóda System.exit ().
- Keď dôjde k výnimke v konečne bloku.
Poďme implementovať niekoľko programov na demonštráciu posledného bloku.
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...'); } } Výkon
Vyššie uvedený program zobrazuje blok try-catch-konečne. V bloku try sa vykoná platná operácia, a preto nie je vyvolaná žiadna výnimka. Preto sa kontrola neodovzdáva, aby sa chytila z pokusu, ale aby sa nakoniec zablokovala.
Nasledujúci program je ďalším príkladom bloku try-catch-konečne, ale v tomto prípade je v bloku try vyvolaná výnimka, pretože vykonávame operáciu delenia nulou. Takto je blok konečne vykonaný po vykonaní bloku blokovania try.
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...'); } } Výkon
Vyvolajte výnimku v prostredí Java
Java poskytuje kľúčové slovo „throw“, pomocou ktorého môžeme výslovne zaviesť výnimky v kóde. Napríklad, ak kontrolujeme aritmetické operácie a chceme po kontrole operandov vyvolať nejaké výnimky, môžeme to urobiť pomocou kľúčového slova ‘throw’.
c # otázky a odpovede na pohovory
Pomocou kľúčového slova throw môžeme hádzať začiarknuté alebo nezaškrtnuté výnimky. Kľúčové slovo throw sa používa aj na vyvolanie vlastných výnimiek.
Všeobecná syntax kľúčového slova throw je:
throw exception; or throw new exception_class('error message'); Ďalej je uvedený ukážkový program na demonštráciu kľúčového slova 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...'); } } Výkon
Vo vyššie uvedenom programe používame metódu na validáciu veku. Ak je vek<18, then an exception is thrown to indicate the age is not valid.
Vrhá doložku
Videli sme try block vyhlásiť výnimky. Obsahuje kód, ktorý môže spôsobiť výnimky. Existuje ďalší spôsob, ako vyhlásiť výnimku, a to pomocou kľúčového slova „throws“.
Deklarácia výnimky pomocou kľúčového slova „throws“ hovorí programátorovi, že po kľúčovom slove „throws“ môže existovať výnimka, a programátor by mal pre túto výnimku poskytnúť zodpovedajúci kód obslužného programu, aby sa udržal normálny tok programu.
Vyvstáva však otázka, prečo potrebujeme kľúčové slovo „vrhá“, keď máme spoľahlivejší blok try-catch na deklarovanie a spracovanie výnimiek?
Jedným z dôvodov je, že sa zvyšuje počet výnimiek, ktoré sa môžu pravdepodobne vyskytnúť, a zvyšuje sa aj počet blokov zachytávania, ktoré spracovávajú výnimky, pretože jeden blok zachytávania dokáže spracovať iba jednu výnimku.
Podobne, ak je v programe veľa metód a každá z nich má množstvo výnimiek, stane sa kód zbytočne dlhým a neovládateľným.
Deklarovanie výnimky pomocou throws - kľúčového slova v podpise metódy a následné spracovanie volania metódy pomocou try-catch sa teda javí ako životaschopné riešenie.
Ďalšou výhodou deklarovania výnimiek pomocou kľúčového slova throws je, že sme nútení výnimky spracovávať. Ak neposkytneme obslužnú rutinu pre deklarovanú výnimku, program spôsobí chybu.
Všeobecná syntax kľúčového slova throws je nasledovná:
return_type method_name() throws exception_class_name{ //method code } Poďme teraz implementovať program Java na demonštráciu kľúčového slova „vrhá“.
V tomto programe máme triedu Example_throw, v ktorej máme metódu testMethod. V podpise tejto testMethod deklarujeme pomocou kľúčového slova throws dve výnimky IOException a Arithmetic Exception. Potom v hlavnej funkcii vyvolá vyvolané výnimky blok chytania.
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); } } }Výkon
často kladené otázky
Otázka č. 1) Kedy použiť vrhače hodu VS try-catch v Jave?
Odpoveď: Kľúčové slovo „throws“ sa používa na vyhlásenie výnimky podpisom metódy. Kľúčové slovo throw sa používa na výslovné použitie výnimky. Blok try-catch sa používa na zvládnutie výnimiek vyvolaných ostatnými.
Otázka 2) Môžeme použiť hody, vyskúšať a chytiť jednou metódou?
Odpoveď: Nie. Výnimku nemôžete vyhodiť a rovnako ju chytiť rovnakou metódou. Výnimku, ktorá je deklarovaná pomocou vrhov, treba vyriešiť volanie metódy, ktorá volá metódu, ktorá výnimku vyvolala.
Otázka 3) Čo sa stane, keď blok chytenia spôsobí výnimku?
Odpoveď: Ak je v bloku catch vyvolaná výnimka, program zastaví vykonávanie. V prípade, že program musí pokračovať, musí existovať samostatný blok try-catch na spracovanie výnimky vyvolanej v bloku catch.
Otázka č. 4) Čo je try-catch-konečne v Jave?
Odpoveď: Blok try-catch-konečne obsahuje tri bloky, tj. Skúste blok, blok bloku a nakoniec blok.
Try block obsahuje kód, ktorý by mohol spôsobiť výnimku. Catch block obsahuje obslužný program výnimiek pre výnimky v bloku try. Blok nakoniec obsahuje kritický kód, ktorý sa vykoná bez ohľadu na to, či došlo k výnimke alebo nie.
Otázka č. 5) Môže konečne zablokovať pokus o úlovok?
Odpoveď: Áno, ak máme kód na vyčistenie, ktorý by mohol vyhodiť výnimku v bloku konečne, môžeme mať blok try-catch. Vyzerá to však škaredo.
Záver
V tomto tutoriáli sme diskutovali o rôznych kľúčových slovách používaných pri spracovávaní výnimiek v Jave. Diskutovali sme o kľúčových slovách ako vyskúšať, chytiť, konečne, hodiť a hodiť.
Kód, ktorý prípadne vyvolá výnimku, je uzavretý v bloku try a catch, ktorý poskytuje obslužnú rutinu pre výnimku. Konečný blok vykoná kód v ňom uzavretý bez ohľadu na to, či je vyvolaná výnimka alebo nie. Konečný blok spravidla nasleduje po bloku try alebo try-catch.
Kľúčové slovo throws používame na deklarovanie výnimiek podpisom metódy a throw sa používa explicitne na vyvolanie výnimiek. Zvyčajne používame kľúčové slovo throw na vyvolanie vlastných výnimiek.
=> Vyskúšajte Sprievodcu dokonalým školením Java tu.
Odporúčané čítanie
- Výnimky Java a spracovanie výnimiek s príkladmi
- Ako spracovať výnimku ArrayIndexOutOfBoundsException v Jave?
- Výukový program JAVA pre začiatočníkov: viac ako 100 praktických výučbových programov Java Video
- Spracovanie výnimiek JDBC - Ako zaobchádzať s výnimkami SQL
- Výukový program na spracovanie výnimiek C # s príkladmi kódu
- Kompletný sprievodca spracovaním výnimiek PL SQL s príkladmi
- Spracovanie výnimiek v C ++
- Python Try Except - Python Handling Exception with examples