try catch finally
W tym samouczku omówimy różne słowa kluczowe używane w Javie do obsługi wyjątków, takie jak Try, Catch, Final, Throw i Throws z przykładami:
W naszych poprzednich samouczkach widzieliśmy podstawy obsługi wyjątków w Javie wraz z różnymi wyjątkami obsługiwanymi przez klasę Java Exception. Szczegółowo omówiliśmy również wyjątek NullPointerException.
Możemy uwzględnić wyjątki w naszym programie, używając określonych słów kluczowych, które są dostarczane w języku Java. Te słowa kluczowe definiują różne bloki kodu, które ułatwiają definiowanie i obsługę wyjątków.
=> Odwiedź tutaj ekskluzywną serię samouczków szkoleniowych Java.
Czego się nauczysz:
Spróbuj, złap, wreszcie w Javie
Poniższe słowa kluczowe są używane w Javie do obsługi wyjątków.
- Próbować
- Złapać
- Wreszcie
- Rzucać
- Rzuty
Poniższa tabela pokrótce opisuje te słowa kluczowe.
| Słowo kluczowe | Opis |
|---|---|
| Próbować | Określamy blok kodu, który może spowodować wyjątek, w specjalnym bloku za pomocą słowa kluczowego „Try”. |
| Złapać | Zgłoszony wyjątek musi zostać przechwycony przez program. Odbywa się to za pomocą słowa kluczowego „catch”. Tak więc blok catch następuje po bloku try, który zgłasza wyjątek. Słowo kluczowe catch powinno być zawsze używane z try. |
| Wreszcie | Czasami mamy ważny kod w naszym programie, który musi zostać wykonany niezależnie od tego, czy wyjątek został zgłoszony, czy nie. Ten kod jest umieszczony w specjalnym bloku zaczynającym się od słowa kluczowego „Wreszcie”. Blok Final następuje po bloku Try-catch. |
| Rzucać | Słowo kluczowe „throw” służy do jawnego zgłaszania wyjątku. |
| Rzuty | Słowo kluczowe „Zgłasza” nie zgłasza wyjątku, ale służy do deklarowania wyjątków. To słowo kluczowe służy do wskazania, że w programie lub metodzie może wystąpić wyjątek. |
W tym samouczku omówimy szczegółowo wszystkie powyższe słowa kluczowe wraz z przykładami programowania.
Spróbuj Block In Java
Zawsze, gdy piszemy program, może istnieć kod, który podejrzewamy, że może zgłosić wyjątek. Na przykład, możemy podejrzewać, że w kodzie może wystąpić operacja „dzielenia przez zero”, która spowoduje zgłoszenie wyjątku.
Ten kod, który może zgłosić wyjątek, jest umieszczony w bloku ze słowem kluczowym „try”. Zatem blok try zawiera kod lub zestaw instrukcji, które mogą zgłosić wyjątek.
Ogólna składnia bloku try jest następująca:
try{ //set of statements that can raise exception } Dlatego, jeśli programista uważa, że pewne instrukcje spowodują wyjątki, należy je zamknąć w bloku try. Zauważ, że gdy wyjątek występuje w określonej instrukcji w bloku try, reszta kodu nie jest wykonywana.
Gdy wyjątek występuje w bloku try w określonej instrukcji, wychodzi sterowanie i program kończy się nagle. Aby zapobiec tak nagłemu przerwaniu programu, powinniśmy „obsłużyć” ten wyjątek. Ta obsługa jest wykonywana za pomocą słowa kluczowego „catch”. Tak więc po bloku try zawsze następuje blok catch.
Złap blok w Javie
Do obsługi wyjątków używamy bloku catch. To jest blok ze słowem kluczowym „catch”. Blok catch następuje po bloku try.
Za każdym razem, gdy w bloku try wystąpi wyjątek, wykonywany jest kod w bloku catch, który odpowiada wyjątkowi.
Ogólna składnia bloku catch to:
catch (Exception e){ //code to handle exception e }Ogólnie zadeklarowany wyjątek musi być klasą nadrzędną wszystkich wyjątków, tj. Exception. Ale jeśli istnieje więcej niż jeden wyjątek, możemy również napisać określone typy wyjątków lub wygenerowane wyjątki.
Następnie omówimy blok try-catch. Zauważ, że dla każdego bloku try możemy mieć wiele bloków catch.
Try-Catch Java
Ogólna składnia bloku try-catch jest pokazana poniżej:
try{ //code causing exception } catch (exception (exception_type) e (object)) { //exception handling code }Blok try może mieć wiele wierszy kodu, które mogą wywoływać wiele wyjątków. Każdy z tych wyjątków jest obsługiwany przez niezależny blok catch.
Ogólna obsługa wyjątków, obiekt e klasy Exception może obsłużyć wszystkie wyjątki, ale jeśli chcemy obsługiwać określone wyjątki, zaleca się określenie ogólnej obsługi wyjątków jako ostatniego bloku catch.
Java Try Catch Example
Teraz zademonstrujemy blok try-catch w Javie. Tutaj, w bloku try, definiujemy operację dzielenia. Dzielnik wynosi zero. Zatem stwierdzenie, które dzieli te dwie liczby, wywołuje wyjątek arytmetyczny. Mamy blok catch, który definiuje procedurę obsługi wyjątku arytmetycznego.
Poniżej podano przykładowy program w języku 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.'); } } Wynik
pytania na rozmowę kwalifikacyjną do testowania oprogramowania dla doświadczonych kandydatów
Łapanie wielu wyjątków
Jak już wspomniano, blok try może zawierać kod, który zgłasza więcej niż jeden wyjątek. W takim przypadku do obsługi każdego wyjątku będziemy potrzebować więcej niż jednego bloku catch. Po jednym bloku try może następować wiele bloków catch. Każdy blok catch będzie obsługiwał niezależne wyjątki.
W przypadku wielu bloków catch musimy pamiętać o poniższych punktach:
- W programie Java w dowolnym momencie może wystąpić tylko jeden wyjątek. Ponadto w dowolnym momencie wykonywany jest tylko jeden blok catch.
- Bloki wielokrotne catch powinny być uporządkowane w taki sposób, aby najpierw był blok catch dla najbardziej szczegółowego wyjątku, a dopiero potem ogólny.
Na przykład, jeśli mamy ArithmeticException i general Exception, to najpierw pojawi się blok catch obsługujący ArithmeticException, a następnie blok catch obsługujący wyjątek.
Poniższy przykład ilustruje wiele bloków 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'); } } Wynik
W powyższym programie jest zgłaszany ArithmeticException, który jest przechwytywany w pierwszym bloku catch. Gdyby ten blok catch nie został określony, wyjątek zostałby propagowany do uogólnionego bloku catch.
Zmodyfikujmy nieco powyższy program, aby blok try wywoływał dwa wyjątki. Zobaczmy teraz wynik.
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'); } } Wynik
Jeśli widzimy te dane wyjściowe, pokazuje on wyrzucony wyjątek ArrayIndexOutOfBoundsException. Dzieje się tak, ponieważ instrukcja, która wywołuje ArrayIndexOutOfBoundsException, jest wykonywana jako pierwsza. Wyjątek jest zgłaszany, a formant przechodzi do odpowiedniego bloku catch.
Zagnieżdżony Try-Catch
Blok try wewnątrz innego bloku try nazywany jest zagnieżdżonym blokiem try. Potrzebujemy takich struktur w pewnych sytuacjach, gdy fragment kodu zawarty w kodzie try może być taki, że niektóre wiersze wywołują określone wyjątki, a inny fragment kodu zupełnie inny wyjątek.
W przypadku zagnieżdżonych bloków try, najpierw wykonywany jest najbardziej wewnętrzny blok try i obsługiwany jest wyjątek. Jeśli najbardziej wewnętrzny blok try nie ma pasującego bloku catch, to jest propagowany o jeden poziom w górę do swojego nadrzędnego bloku try. W ten sposób wyjątek jest propagowany w górę, aż zostanie znaleziony pasujący program obsługi wyjątków.
Jeśli nie ma programu obsługi wyjątków pasującego do wyjątku, program jest nagle przerywany z komunikatem wygenerowanym przez system.
Ogólna składnia zagnieżdżonego bloku try jest podana poniżej:
try { //try_block 1; try { //try_block 2; } catch(Exception e) { //exception handler code } } catch(Exception e) { //exception handler code }Zaimplementujmy program do zademonstrowania zagnieżdżonego 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'); } } Wynik
W powyższym programie mamy dwa bloki try zawarte w głównym bloku try. Oba wewnętrzne bloki try mają kod, który wywołuje ArithmeticException. Ale zapewniliśmy pasujący blok catch tylko dla pierwszego bloku, a nie dla drugiego bloku try.
Dlatego drugi blok propaguje swój wyjątek do głównego bloku try, a następnie obsługuje go. Widać to na podstawie wyników.
Wreszcie blok w Javie
Do tej pory widzieliśmy try-catch i zagnieżdżony blok try. Wiemy, że kod, który ma zgłosić wyjątek, jest umieszczany w bloku try. Gdy wystąpi wyjątek, pozostała część kodu w bloku try nie jest wykonywana.
Program kończy się nagle, jeśli wyjątek nie jest obsługiwany lub kontrola jest przekazywana do programu obsługi wyjątków.
W takiej sytuacji pojawia się potrzeba dołączenia kodu, który ma zostać wykonany niezależnie od tego, czy wystąpi wyjątek, czy nie. Oznacza to, że wykonamy fragment kodu nawet wtedy, gdy wystąpi wyjątek, a także wtedy, gdy wyjątek nie wystąpi.
Ale ponieważ blok try kończy działanie po wystąpieniu wyjątku, nie możemy umieścić tego kodu w bloku try. Podobnie, blok catch ma obsługę wyjątków, więc nie możemy go również umieścić w bloku catch.
Dlatego potrzebujemy oddzielnego bloku, który zawiera kod, który jest wykonywany niezależnie od tego, czy wystąpi wyjątek, czy nie. Java udostępnia blok „na końcu”, który zawiera ten fragment kodu.
Stąd ostateczny blok w Javie może zawierać krytyczne instrukcje, które mają zostać wykonane w programie. Wykonywanie tych instrukcji powinno być wykonywane nawet wtedy, gdy wystąpi wyjątek lub nie.
W związku z tym umieścimy kod, taki jak połączenia zamykające, obiekty strumieniowe itp., Lub dowolny kod czyszczący w bloku final, aby można je było wykonać nawet w przypadku wystąpienia wyjątku.
Ostatni blok w Javie jest zwykle umieszczany po bloku try lub catch. Zauważ, że ostatni blok nie może istnieć bez bloku try. Kiedy ostatni blok jest dołączony do try-catch, staje się „ wreszcie spróbuj złapać ”Blok.
Możemy pominąć ostatni blok w kodzie obsługi wyjątków. Oznacza to, że ostatecznie blok jest opcjonalny.
Jeśli blok try nie zgłosi żadnego wyjątku, to ostatni blok zostanie wykonany po bloku try. Jeśli w bloku try jest wyjątek, sterowanie przejdzie najpierw do bloku catch, a następnie do bloku końcowego.
Wyjątek występujący w final block zachowuje się tak samo, jak każdy inny wyjątek. Nawet jeśli blok try zawiera instrukcję return lub instrukcje rozgałęziające, takie jak break i continue, ostatni blok będzie nadal wykonywany.
Pamiętając o tych kwestiach, przejdźmy dalej do ogólnej składni i przykładów końcowego bloku.
Ogólna składnia ostatniego bloku jest następująca:
try { //code that might raise exception }catch { //code that handles exception }finally { //mandatory code to be executed }Chociaż ostatecznie blok jest zawsze wykonywany, są pewne sytuacje lub przypadki, w których nie jest on wykonywany.
Oto poniższe przypadki:
- Kiedy nić jest martwa.
- Gdy używana jest metoda System.exit ().
- Kiedy w ostatnim bloku wystąpi wyjątek.
Zaimplementujmy kilka programów, aby zademonstrować ostatni 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...'); } } Wynik
Powyższy program pokazuje blok try-catch-last. W bloku try wykonywana jest prawidłowa operacja, dlatego nie jest zgłaszany żaden wyjątek. Dlatego kontrola nie jest przekazywana do przechwycenia z próby, ale do ostatecznego zablokowania.
Poniższy program jest kolejnym przykładem bloku try-catch-final, ale w tym przypadku wyjątek jest zgłaszany w bloku try, gdy wykonujemy operację dzielenia przez zero. Zatem ostatni blok jest wykonywany po wykonaniu bloku try the catch.
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...'); } } Wynik
Wrzuć wyjątek w Javie
Java udostępnia słowo kluczowe „throw”, za pomocą którego możemy jawnie zgłosić wyjątki w kodzie. Na przykład, jeśli sprawdzamy operacje arytmetyczne i chcemy zgłosić wyjątki po sprawdzeniu operandów, możemy to zrobić za pomocą słowa kluczowego „throw”.
jak otworzyć plik open.dat na komputerze Mac
Używając słowa kluczowego throw, możemy wyrzucić zaznaczone lub niezaznaczone wyjątki. Słowo kluczowe throw jest również używane do zgłaszania wyjątków niestandardowych.
Ogólna składnia słowa kluczowego throw to:
throw exception; or throw new exception_class('error message'); Poniżej podano przykładowy program do zademonstrowania słowa kluczowego 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...'); } } Wynik
W powyższym programie używamy metody do walidacji wieku. Jeśli wiek jest<18, then an exception is thrown to indicate the age is not valid.
Klauzula rzucania
Widzieliśmy próbę blokowania deklarowania wyjątków. Zawiera kod, który może generować wyjątki. Istnieje inny sposób zadeklarowania wyjątku i jest to użycie słowa kluczowego „throws”.
Deklaracja wyjątku przy użyciu słowa kluczowego „throws” informuje programistę, że może istnieć wyjątek określony po słowie kluczowym „throws”, a programista powinien dostarczyć odpowiedni kod obsługi dla tego wyjątku, aby zachować normalny przepływ programu.
Powstaje jednak pytanie, dlaczego potrzebujemy słowa kluczowego „throws”, skoro mamy bardziej niezawodny blok try-catch do deklarowania i obsługi wyjątków?
Jednym z powodów jest wzrost liczby wyjątków, które mogą wystąpić, liczba bloków catch, które obsługują wyjątki, również wzrasta, ponieważ jeden blok catch może obsłużyć tylko jeden wyjątek.
Podobnie, jeśli w programie jest wiele metod, a każda metoda ma wiele wyjątków, kod stanie się niepotrzebnie długi i niemożliwy do zarządzania.
Dlatego zadeklarowanie wyjątku za pomocą słowa kluczowego throws w sygnaturze metody, a następnie obsługa wywołania metody za pomocą try-catch wydaje się być wykonalnym rozwiązaniem.
Kolejną zaletą deklarowania wyjątków za pomocą słowa kluczowego throws jest to, że jesteśmy zmuszeni do obsługi wyjątków. Jeśli nie udostępnimy obsługi dla zadeklarowanego wyjątku, program zgłosi błąd.
Ogólna składnia słowa kluczowego throws jest następująca:
return_type method_name() throws exception_class_name{ //method code } Zaimplementujmy teraz program Java, aby zademonstrować słowo kluczowe „throws”.
W tym programie mamy klasę Example_throw, w której mamy metodę testMethod. W podpisie tego testMethod deklarujemy dwa wyjątki IOException i Arithmetic Exception za pomocą słowa kluczowego throws. Następnie w funkcji main generowane wyjątki są obsługiwane przez blok 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); } } }Wynik
Często Zadawane Pytania
P # 1) Kiedy używać rzutów rzutów VS try-catch w Javie?
Odpowiedź: Słowo kluczowe „throws” służy do deklarowania wyjątku z sygnaturą metody. Słowo kluczowe throw służy do jawnego zgłaszania wyjątku. Blok try-catch jest używany do obsługi wyjątków rzucanych przez innych.
Q # 2) Czy możemy używać rzutów, próbować łapać w jednej metodzie?
Odpowiedź: Nie. Nie możesz rzucić wyjątku, a także złapać go w ten sam sposób. Wyjątek, który jest zadeklarowany przy użyciu rzutów, ma być obsługiwany w metodzie wywołującej, która wywołuje metodę, która zgłosiła wyjątek.
P # 3) Co się dzieje, gdy blok catch zgłasza wyjątek?
Odpowiedź: Gdy wyjątek zostanie zgłoszony w bloku catch, program zatrzyma wykonywanie. Na wypadek, gdyby program musiał kontynuować, musi istnieć oddzielny blok try-catch do obsługi wyjątku zgłoszonego w bloku catch.
Q # 4) Co to jest wreszcie próba złapania w Javie?
Odpowiedź: Blok try-catch-final zawiera trzy bloki, tj. Blok try, blok catch i wreszcie blok.
Blok try zawiera kod, który może zgłosić wyjątek. Blok Catch zawiera procedurę obsługi wyjątków dla wyjątków w bloku try. Ostatni blok zawiera krytyczny kod, który zostanie wykonany niezależnie od tego, czy wyjątek wystąpił, czy nie.
P # 5) Czy w końcu można zablokować i spróbować złapać?
Odpowiedź: Tak, jeśli mamy kod czyszczący, który może zgłosić wyjątek w bloku final, wówczas możemy mieć blok try-catch. Jednak wygląda brzydko.
Wniosek
W tym samouczku omówiliśmy różne słowa kluczowe używane w obsłudze wyjątków w Javie. Omówiliśmy słowa kluczowe, takie jak próbować, łapać, wreszcie rzucać i rzucać.
Kod, który prawdopodobnie zgłosi wyjątek, jest zawarty w bloku try, a catch zapewnia obsługę wyjątku. Ostatecznie blok wykonuje zawarty w nim kod, niezależnie od tego, czy wyjątek został zgłoszony, czy nie. Blok final generalnie następuje po bloku try lub try-catch.
Używamy słowa kluczowego throws do deklarowania wyjątków z sygnaturą metody, a throw jest używany jawnie do zgłaszania wyjątków. Zwykle używamy słowa kluczowego throw, aby zgłaszać niestandardowe wyjątki.
=> Sprawdź idealny przewodnik szkoleniowy języka Java tutaj.
rekomendowane lektury
- Wyjątki Java i obsługa wyjątków z przykładami
- Jak obsługiwać wyjątek ArrayIndexOutOfBoundsException w języku Java?
- Samouczek JAVA dla początkujących: ponad 100 praktycznych samouczków wideo Java
- Obsługa wyjątków JDBC - jak obsługiwać wyjątki SQL
- C # samouczek obsługi wyjątków z przykładami kodu
- Kompletny przewodnik po obsłudze wyjątków PL SQL z przykładami
- Obsługa wyjątków w C ++
- Python Try Except - Wyjątek obsługi języka Python z przykładami