try catch finally
V tomto kurzu se budeme zabývat různými klíčovými slovy používanými v Javě pro zpracování výjimek, jako jsou Try, Catch, Finally, Throw a Throws s příklady:
V našich předchozích cvičeních jsme viděli základy zpracování výjimek v Javě spolu s různými výjimkami podporovanými třídou Java Exception. Také jsme podrobně diskutovali o NullPointerException.
Můžeme zahrnout výjimky do našeho programu pomocí určitých klíčových slov, která jsou poskytována v Javě. Tato klíčová slova definují různé bloky kódu, které usnadňují definování a zpracování výjimek.
=> Navštivte zde exkluzivní sérii výukových programů Java.
Co se naučíte:
Zkuste, chyťte, nakonec v Javě
Níže uvedená klíčová slova se používají v Javě pro zpracování výjimek.
- Snaž se
- Úlovek
- Konečně
- Házet
- Vrhá
Následující tabulka stručně popisuje tato klíčová slova.
| Klíčové slovo | Popis |
|---|---|
| Snaž se | Blok kódu, který by mohl vést k výjimce, specifikujeme ve speciálním bloku s klíčovým slovem „Try“. |
| Úlovek | Když je výjimka vyvolána, musí být chycena programem. To se provádí pomocí klíčového slova „catch“. Blok catch tedy následuje blok try, který vyvolává výjimku. Klíčové slovo catch by mělo být vždy použito s try. |
| Konečně | Někdy máme v našem programu důležitý kód, který je třeba provést bez ohledu na to, zda je vyvolána výjimka. Tento kód je umístěn do zvláštního bloku začínajícího klíčovým slovem „Konečně“. Blok Konečně navazuje na blok Try-catch. |
| Házet | Klíčové slovo „throw“ se používá k výslovnému vyvolání výjimky. |
| Vrhá | Klíčové slovo „Hodí“ nevyvolá výjimku, ale používá se k deklaraci výjimek. Toto klíčové slovo se používá k označení, že v programu nebo metodě může dojít k výjimce. |
V tomto tutoriálu probereme všechna výše uvedená klíčová slova podrobně spolu s příklady programování.
Zkuste blokovat v Javě
Kdykoli píšeme program, mohl by existovat kód, o kterém se domníváme, že by mohl vyvolat výjimku. Například, můžeme mít podezření, že v kódu může být operace „dělení nulou“, která vyvolá výjimku.
Tento kód, který by mohl vyvolat výjimku, je uzavřen v bloku s klíčovým slovem „try“. Blok try tedy obsahuje kód nebo sadu příkazů, které mohou vyvolat výjimku.
Obecná syntaxe bloku try je následující:
try{ //set of statements that can raise exception } Pokud si tedy programátor myslí, že určité příkazy zvýší výjimky, uzavřete tyto příkazy do bloku try. Všimněte si, že když dojde k výjimce u konkrétního příkazu v bloku try, zbytek kódu se neprovede.
Když dojde k výjimce v bloku try u konkrétního příkazu, pak vyjde ovládací prvek a program se náhle ukončí. Abychom zabránili tomuto náhlému ukončení programu, měli bychom tuto výjimku „zpracovat“. Tato manipulace se provádí pomocí klíčového slova „catch“. Takže blok try má vždy za sebou blok catch.
Chytit blok v Javě
K zpracování výjimek používáme blok catch. Toto je blok s klíčovým slovem „catch“. Blok catch následuje blok try.
Kdykoli dojde k výjimce v bloku try, provede se kód v bloku catch, který odpovídá výjimce.
Obecná syntaxe bloku catch je:
catch (Exception e){ //code to handle exception e }Obecně platí, že deklarovaná výjimka musí být nadřazenou třídou všech výjimek, tj. Exception. Ale pokud existuje více než jedna výjimka, můžeme také napsat konkrétní typy výjimek nebo generované výjimky.
Dále probereme blok try-catch. Všimněte si, že pro každý blok try můžeme mít několik bloků catch.
Try-Catch Java
Obecná syntaxe bloku try-catch je uvedena níže:
try{ //code causing exception } catch (exception (exception_type) e (object)) { //exception handling code }Blok try může mít více řádků kódu, které mohou vyvolat více výjimek. Každá z těchto výjimek je zpracována nezávislým blokem zachycení.
Obecný obslužný program výjimek, objekt e třídy Exception, dokáže zpracovat všechny výjimky, ale pokud chceme zpracovat konkrétní výjimky, je vhodné určit obecný obslužný program výjimek jako poslední blok úlovku.
Java Zkuste příklad úlovku
Nyní si ukážeme blok try-catch v Javě. Tady v bloku try definujeme operaci dělení. Dělitel je nula. Výrok, který rozděluje dvě čísla, tedy vyvolává aritmetickou výjimku. Máme blok catch, který definuje obslužnou rutinu pro aritmetickou výjimku.
Níže je uveden ukázkový program 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ýstup
java předává pole metodě odkazem
Chytání více výjimek
Jak již bylo zmíněno, blok try může obsahovat kód, který vyvolá více než jednu výjimku. V takovém případě budeme ke zpracování každé výjimky potřebovat více než jeden blok zachycení. Po jednom bloku pokusu může následovat několik bloků úlovku. Každý blok catch bude zpracovávat nezávislé výjimky.
V případě více bloků úlovku si musíme pamatovat níže uvedené body:
- V programu Java může kdykoli dojít pouze k jedné výjimce. Také se kdykoli provede pouze jeden blok zachycení.
- Více bloků úlovku by mělo být uspořádáno takovým způsobem, že blok úlovku pro nejkonkrétnější výjimku by měl přijít jako první a poté jako obecný.
Například, pokud máme ArithmeticException a obecnou výjimku, pak nejprve přijde ArithmeticException zpracování bloku úlovku a poté výjimka zpracování bloku úlovku.
Níže uvedený příklad ukazuje více bloků ú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ýstup
Ve výše uvedeném programu je vyvolána ArithmeticException, která je zachycena v prvním bloku zachycení. Pokud tento blok zachycení nebyl zadán, pak by se výjimka rozšířila na zobecněný blok zachycení.
Pojďme mírně upravit výše uvedený program tak, aby blok try vyvolal dvě výjimky. Nyní se podívejme na 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ýstup
Pokud vidíme tento výstup, ukazuje, že je vyvolána ArrayIndexOutOfBoundsException. Je to proto, že příkaz, který vyvolává ArrayIndexOutOfBoundsException, je proveden jako první. Výjimka je vyvolána a ovládací prvek přejde na odpovídající blok catch.
Vnořené Try-Catch
Blok try v jiném bloku try se nazývá vnořený blok try. Potřebujeme takové struktury v určitých situacích, kdy část kódu obsažená v try kódu může být taková, že některé řádky vyvolávají určité výjimky a jiná část kódu vyvolává úplně jinou výjimku.
V případě vnořených bloků try se nejprve provede nejvnitřnější blok try a zpracuje se výjimka. Pokud nejvnitřnější blok try nemá odpovídající blok chytání, pak se šíří o jednu úroveň výše do svého nadřazeného bloku try. Tímto způsobem se výjimka šíří nahoru, dokud není nalezena odpovídající obslužná rutina výjimky.
Pokud výjimce neodpovídá žádný obslužný program výjimek, je program náhle ukončen zprávou vygenerovanou systémem.
Obecná syntaxe vnořeného bloku try je uvedena níže:
try { //try_block 1; try { //try_block 2; } catch(Exception e) { //exception handler code } } catch(Exception e) { //exception handler code }Pojďme implementovat program pro demonstraci vnořené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ýstup
Ve výše uvedeném programu máme dva try bloky uzavřené v hlavním try bloku. Oba vnitřní try bloky mají kód, který vyvolává ArithmeticException. Ale poskytli jsme odpovídající blok úlovků pouze pro první blok a ne pro druhý blok pokusu.
Druhý blok proto šíří svou výjimku na hlavní blok try a poté jej zpracovává. To je patrné z výstupu.
Nakonec zablokujte v Javě
Zatím jsme viděli blok try-catch a vnořený try. Víme, že kód, od kterého se očekává zvýšení výjimky, je vložen do bloku try. Když dojde k výjimce, zbytek kódu v bloku try se neprovede.
Program se náhle ukončí, pokud není zpracována výjimka nebo je ovládací prvek předán obslužné rutině výjimky.
V takové situaci vyvstává potřeba zahrnout kód, který má být proveden bez ohledu na to, zda dojde k výjimce či nikoli. To znamená, že provedeme část kódu, i když dojde k výjimce a také když k výjimce nedojde.
Ale jak try block exits po vyvolání výjimky nemůžeme dát tento kód do try bloku. Podobně má catch blok obsluhu výjimek, takže to nemůžeme dát ani do catch bloku.
Potřebujeme tedy samostatný blok, který obsahuje kód, který se provede bez ohledu na to, zda dojde k výjimce. Java poskytuje blok „konečně“, který obsahuje tuto část kódu.
Proto konečný blok v Javě může obsahovat kritické příkazy, které mají být v programu provedeny. Provádění těchto příkazů by mělo být provedeno, i když dojde k výjimce nebo ne.
Proto do konečného bloku vložíme kód, jako je zavírání připojení, streamování objektů atd. Nebo jakýkoli kód pro vyčištění, aby je bylo možné spustit, i když dojde k výjimce.
Konečný blok v Javě se obvykle umístí po bloku try nebo catch. Všimněte si, že konečný blok nemůže existovat bez bloku try. Když je konečný blok součástí try-catch, stane se „ zkuste chytit-konečně “Blok.
Můžeme přeskočit konečný blok v kódu pro zpracování výjimek. To znamená, že konečně blok je volitelný.
Pokud blok try nevyvolá žádnou výjimku, bude blok nakonec spuštěn po bloku try. Pokud v bloku try existuje výjimka, pak ovládací prvek přejde nejprve do bloku catch a poté do bloku final.
Výjimka vyskytující se v bloku finally se chová stejným způsobem jako jakákoli jiná výjimka. I když blok try obsahuje příkaz return nebo větvicí příkazy jako break and continue, nakonec bude blok nakonec proveden.
Mějte na paměti tyto body a pokračujte v obecné syntaxi a příkladech konečného blokování.
Obecná syntaxe bloku finally je následující:
try { //code that might raise exception }catch { //code that handles exception }finally { //mandatory code to be executed }Ačkoli se blok nakonec provede vždy, existují určité situace nebo případy, kdy se neprovede.
Jedná se o následující případy:
- Když je nit mrtvá.
- Při použití metody System.exit ().
- Když dojde k výjimce v bloku finally.
Provedeme několik programů, abychom demonstrovali konečný blok.
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ýstup
Výše uvedený program ukazuje blok try-catch-konečne. V bloku try se provádí platná operace, a proto není vyvolána žádná výjimka. Ovládací prvek tedy není předán k zachycení z try, ale ke konečnému zablokování.
Následující program je dalším příkladem bloku try-catch-konečne, ale v tomto případě je výjimka vyvolána v bloku try, protože provádíme operaci dělení nulou. Tedy konečný blok je proveden po provedení pokusu o zachycení bloku.
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ýstup
Vyvolání výjimky v Javě
Java poskytuje klíčové slovo „throw“, pomocí kterého můžeme explicitně vyvolat výjimky v kódu. Například, pokud kontrolujeme aritmetické operace a chceme po kontrole operandů vyvolat nějaké výjimky, můžeme tak učinit pomocí klíčového slova ‘throw’.
Pomocí klíčového slova throw můžeme vyvolat zaškrtnuté nebo nezaškrtnuté výjimky. Klíčové slovo throw se také používá k vyvolání vlastních výjimek.
Obecná syntaxe klíčového slova throw je:
throw exception; or throw new exception_class('error message'); Níže je uveden ukázkový program k prokázání klíč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ýstup
Ve výše uvedeném programu používáme metodu k ověření věku. Pokud je věk<18, then an exception is thrown to indicate the age is not valid.
Vrhá klauzuli
Viděli jsme try block deklarovat výjimky. Obsahuje kód, který může vyvolat výjimky. Existuje další způsob, jak deklarovat výjimku, a to pomocí klíčového slova „throws“.
Deklarace výjimky pomocí klíčového slova „throws“ říká programátorovi, že po klíčovém slově „throws“ může existovat výjimka a programátor by měl pro tuto výjimku poskytnout odpovídající kód obslužné rutiny, aby se zachoval normální tok programu.
Vyvstává však otázka, proč potřebujeme klíčové slovo „vrhá“, když máme spolehlivější blok try-catch k deklaraci a zpracování výjimek?
Jedním z důvodů je, že se zvyšuje počet výjimek, které se mohou případně vyskytnout, a počet bloků úlovků, které zpracovávají výjimky, se také zvyšuje, protože jeden blok úlovků dokáže zpracovat pouze jednu výjimku.
html5 otázky a odpovědi na pohovory pro zkušené
Podobně, pokud je v programu mnoho metod a každá metoda má řadu výjimek, stane se kód zbytečně dlouhý a nezvládnutelný.
Deklarování výjimky pomocí throws klíčového slova v podpisu metody a následné zpracování volání metody pomocí try-catch se tedy zdá být životaschopným řešením.
Další výhodou deklarování výjimek pomocí throws klíčového slova je, že jsme nuceni tyto výjimky zpracovat. Pokud neposkytneme obslužnou rutinu pro deklarovanou výjimku, program vyvolá chybu.
Obecná syntaxe klíčového slova throws je následující:
return_type method_name() throws exception_class_name{ //method code } Pojďme nyní implementovat program Java, abychom demonstrovali klíčové slovo „vrhá“.
V tomto programu máme třídu Example_throw, ve které máme metodu testMethod. V podpisu této testMethod deklarujeme dvě výjimky IOException a Arithmetic Exception pomocí klíčového slova throws. Potom v hlavní funkci jsou vyvolané výjimky zpracovány blokem 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); } } }Výstup
Často kladené otázky
Otázka č. 1) Kdy použít házení házet VS try-catch v Javě?
Odpovědět: Klíčové slovo „throws“ se používá k deklaraci výjimky podpisem metody. Klíčové slovo throw se používá k výslovnému vyvolání výjimky. Blok try-catch se používá ke zpracování výjimek vyvolaných ostatními.
Otázka 2) Můžeme použít hody, vyzkoušet a chytit jednou metodou?
Odpovědět: Ne. Nelze vyvolat výjimku a také ji zachytit stejnou metodou. Výjimka, která je deklarována pomocí throws, má být zpracována volající metodou, která volá metodu, která vyvolala výjimku.
Otázka č. 3) Co se stane, když blok catch vyvolá výjimku?
Odpovědět: Když je v bloku chycení vyvolána výjimka, program zastaví provádění. V případě, že program musí pokračovat, musí existovat samostatný blok try-catch pro zpracování výjimky vyvolané v bloku catch.
Otázka č. 4) Co je try-catch-konečne v Javě?
Odpovědět: Blok try-catch-finally obsahuje tři bloky, tj. Try block, catch block a nakonec block.
Try block obsahuje kód, který by mohl vyvolat výjimku. Catch block obsahuje obslužný program výjimek pro výjimky v try bloku. Nakonec blok obsahuje kritický kód, který se spustí bez ohledu na to, zda došlo k výjimce nebo ne.
Otázka č. 5) Může konečně blokovat try-catch?
Odpovědět: Ano, pokud máme čisticí kód, který by mohl v bloku finally vyvolat výjimku, můžeme mít blok try-catch. Vypadá to však ošklivě.
Závěr
V tomto tutoriálu jsme diskutovali o různých klíčových slovech používaných při zpracování výjimek v Javě. Diskutovali jsme o klíčových slovech jako try, chytit, konečně, házet a házet.
Kód, který pravděpodobně vyvolá výjimku, je uzavřen v bloku try a catch poskytuje obslužnou rutinu pro výjimku. Nakonec blok provede kód uzavřený v něm bez ohledu na to, zda je vyvolána výjimka nebo ne. Konečný blok obecně následuje po bloku try nebo try-catch.
Klíčové slovo throws používáme k deklaraci výjimek podpisem metody a throw se používá explicitně k vyvolání výjimek. K vyvolání vlastních výjimek obvykle používáme klíčové slovo throw.
=> Podívejte se na průvodce Perfect Java Training Guide zde.
Doporučené čtení
- Výjimky Java a zpracování výjimek s příklady
- Jak zacházet s ArrayIndexOutOfBoundsException v Javě?
- Výukový program JAVA pro začátečníky: 100+ praktických výukových programů Java Video
- Zpracování výjimek JDBC - Jak zacházet s výjimkami SQL
- Výukový program pro zpracování výjimek C # s příklady kódu
- Kompletní průvodce zpracováním výjimek PL SQL s příklady
- Zpracování výjimek v C ++
- Python Try Except - Python Handling Exception With examples