try catch finally
I denna handledning kommer vi att diskutera olika nyckelord som används i Java för undantagshantering som Try, Catch, Slutligen, Throw och Throws med exempel:
I våra tidigare självstudier har vi sett grunderna för undantagshantering i Java tillsammans med de olika undantagen som stöds av Java Exception-klassen. Vi diskuterade också NullPointerException i detalj.
Vi kan inkludera undantag i vårt program genom att använda vissa nyckelord som tillhandahålls i Java. Dessa nyckelord definierar olika kodblock som underlättar att definiera och hantera undantag.
=> Besök här för den exklusiva Java-utbildningsserien.
Vad du kommer att lära dig:
Försök, fånga, äntligen i Java
Nedanstående nyckelord används i Java för hantering av undantag.
- Prova
- Fånga
- Till sist
- Kasta
- Kastar
Följande tabell beskriver kort dessa nyckelord.
| Nyckelord | Beskrivning |
|---|---|
| Prova | Vi specificerar det kodblock som kan ge upphov till undantaget i ett specialblock med 'Try' -nyckelord. |
| Fånga | När undantaget tas upp måste det fångas av programmet. Detta görs med hjälp av ett 'fångst' -nyckelord. Så ett fångstblock följer försöksblocket som ger ett undantag. Nyckelordet fångst bör alltid användas med ett försök. |
| Till sist | Ibland har vi en viktig kod i vårt program som måste köras oavsett om undantaget kastas eller inte. Den här koden placeras i ett specialblock som börjar med nyckelordet 'Slutligen'. Slutligen följer blocket Try-catch-blocket. |
| Kasta | Nyckelordet ”kasta” används för att kasta undantaget uttryckligen. |
| Kastar | Nyckelordet ”kastar” slänger inte ett undantag utan används för att förklara undantag. Detta nyckelord används för att indikera att ett undantag kan förekomma i programmet eller metoden. |
I denna handledning kommer vi att diskutera alla ovanstående nyckelord i detalj tillsammans med programmeringsexemplen.
Försök blockera i Java
När vi skriver ett program kan det finnas en kod som vi misstänker kan orsaka ett undantag. Till exempel, vi kanske misstänker att det kan finnas en 'division med noll' -åtgärd i koden som ger ett undantag.
Den här koden som kan leda till ett undantag är innesluten i ett block med nyckelordet 'försök'. Så försöksblocket innehåller koden eller uppsättningen uttalanden som kan ge ett undantag.
Den allmänna syntaxen för försöksblocket är som följer:
try{ //set of statements that can raise exception } Därför, om en programmerare tror att vissa uttalanden kommer att leda till undantag, bifoga dessa uttalanden i ett försöksblock. Observera att när ett undantag inträffar vid ett specifikt uttalande i ett försöksblock, så körs inte resten av koden.
När ett undantag inträffar i ett försöksblock vid ett visst uttalande, kommer kontrollen ut och programmet avslutas plötsligt. För att förhindra denna plötsliga avslutning av programmet bör vi 'hantera' detta undantag. Denna hantering sker med hjälp av nyckelordet 'fånga'. Så ett försöksblock har alltid ett fångstblock som följer det.
Fånga block i Java
Vi använder ett fångstycke för att hantera undantag. Detta är blocket med nyckelordet 'fånga'. Fångstblocket följer försöksblocket.
När ett undantag inträffar i försöksblocket körs koden i fångsten som motsvarar undantaget.
Den allmänna syntaxen för fångsten är:
catch (Exception e){ //code to handle exception e }Generellt måste det deklarerade undantaget vara moderklassen för alla undantag, dvs. undantag. Men om det finns mer än ett undantag kan vi också skriva specifika undantagstyper eller genererade undantag.
Därefter kommer vi att diskutera försök-fångst-blocket. Observera att för varje försöksblock kan vi ha flera fångstblock.
Försök fånga Java
Den allmänna syntaxen för try-catch blocket visas nedan:
try{ //code causing exception } catch (exception (exception_type) e (object)) { //exception handling code }Försöksblocket kan ha flera kodrader som kan ge upphov till flera undantag. Var och en av dessa undantag hanteras av ett oberoende fångstblock.
Den generiska undantagshanteraren, objekt e i Exception-klassen kan hantera alla undantag men om vi vill hantera specifika undantag, är det tillrådligt att ange det generiska undantagshanteraren som det senaste fångstblocket.
Java Try Catch Exempel
Låt oss nu visa ett försök-fångstblock i Java. Här i försöksblocket definierar vi en delningsoperation. Delaren är noll. Således ger uttalandet som delar de två siffrorna upp ett aritmetiskt undantag. Vi har ett fångblock som definierar en hanterare för aritmetiska undantag.
Nedan följer ett exempel på Java-program.
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.'); } } Produktion
unix intervju frågor och svar för erfarna
Fångar flera undantag
Som redan nämnts kan ett försöksblock innehålla en kod som höjer mer än ett undantag. I det här fallet behöver vi mer än ett fångstblock för att hantera varje undantag. Ett enda försöksblock kan följas av flera fångstblock. Varje fångstblock hanterar de oberoende undantagen.
När det gäller flera fångstblock måste vi komma ihåg nedanstående punkter:
- I ett Java-program, när som helst, kan endast ett undantag förekomma. Vid varje tillfälle exekveras bara ett fångstblock.
- Flera fångstblock ska beställas på ett sådant sätt att fångstblocket för det mest specifika undantaget bör komma först och sedan generellt.
Till exempel, om vi har ArithmeticException och allmänt undantag kommer fångsten block hantering ArithmeticException kommer först följt av fångsten block hantering Exception.
Nedanstående exempel visar flera fångstblock.
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'); } } Produktion
I ovanstående program höjs ett aritmetiskt undantag som fångas i det första fångblocket. Om detta fångstblock inte angavs skulle undantaget ha spridit sig till det generaliserade fångstblocket.
Låt oss modifiera ovanstående program så att försöksblocket ger två undantag. Låt oss nu se resultatet.
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'); } } Produktion
Om vi ser denna utdata visar den att ArrayIndexOutOfBoundsException kastas. Detta beror på att uttalandet som höjer ArrayIndexOutOfBoundsException körs först. Undantaget kastas och kontrollen går till motsvarande fångstblock.
Nestad Try-Catch
Ett försöksblock inuti ett annat försöksblock kallas ett kapslat försöksblock. Vi behöver sådana strukturer i vissa situationer när en kod som finns i en försökskod kan vara sådan att vissa rader ger vissa undantag och en annan kod ger ett helt annat undantag.
Vid kapslade försöksblock körs först det innersta försöksblocket och undantaget hanteras. Om det innersta försöksblocket inte har ett matchande fångstblock förökas det en nivå upp till det överordnade försöksblocket. På detta sätt sprids undantaget uppåt tills matchande undantagshanterare hittas.
Om det inte finns någon undantagshanterare som matchar undantaget avslutas programmet plötsligt med ett systemgenererat meddelande.
Den allmänna syntaxen för ett kapslat försöksblock ges nedan:
try { //try_block 1; try { //try_block 2; } catch(Exception e) { //exception handler code } } catch(Exception e) { //exception handler code }Låt oss implementera ett program för att demonstrera det kapslade försöket.
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'); } } Produktion
I programmet ovan har vi två försöksblock som är inneslutna i huvudförsöksblocket. Båda de inre försöksblocken har en kod som höjer ArithmeticException. Men vi har tillhandahållit ett matchande fångstblock endast för det första blocket och inte för det andra försöksblocket.
Därför sprider det andra blocket sitt undantag från huvudförsöksblocket och hanterar det sedan. Detta framgår av produktionen.
Slutligen blockera i Java
Hittills har vi sett försöksfånget och kapslat försöksblock. Vi vet att koden som förväntas höja undantaget placeras i ett försöksblock. När ett undantag inträffar körs inte resten av koden i försöksblocket.
Antingen avslutas programmet plötsligt om ett undantag inte hanteras eller om kontrollen skickas till undantagshanteraren.
I en sådan situation uppstår ett behov av att inkludera en kod som ska köras oavsett om ett undantag inträffar eller inte. Det betyder att vi kommer att utföra en kodkod även när ett undantag inträffar och även när undantaget inte förekommer.
Men när försöksblock exits efter att undantaget har höjts kan vi inte lägga den här koden i försöksblocket. På samma sätt har catch block en undantagshanterare, så vi kan inte lägga detta i catch blocket också.
Således behöver vi ett separat block som innehåller en kod som körs oavsett om ett undantag inträffar eller inte. Java tillhandahåller ett 'slutligen' block som innehåller denna kod.
Därför kan ett slutligt block i Java innehålla kritiska uttalanden som ska köras i programmet. Genomförandet av dessa uttalanden bör utföras även när ett undantag inträffar eller inte.
Därför kommer vi att lägga kod som att stänga anslutningar, strömma objekt etc. eller någon saneringskod i det slutliga blocket så att de kan köras även om ett undantag inträffar.
Det slutliga blocket i Java läggs vanligtvis efter ett försök eller fångstblock. Observera att det slutliga blocket inte kan existera utan ett försöksblock. När det slutliga blocket ingår i try-catch, blir det ett “ försök-fånga-äntligen ”Blockera.
Vi kan hoppa över det slutliga blocket i undantagshanteringskoden. Detta innebär att block slutligen är valfritt.
Om försöksblocket inte ger upp något undantag kommer slutligen blocket att köras efter försöksblocket. Om det finns ett undantag i försöksblocket kommer kontrollen att övergå till fångsten först och sedan slutligen blockera.
Ett undantag som inträffar i slutligen blockerar beter sig på samma sätt som alla andra undantag. Även om försöksblocket innehåller returuttalande eller förgreningsuttalanden som bryta och fortsätta, kommer slutligen blocket fortfarande att köras.
Med tanke på dessa punkter fortsätter vi med den allmänna syntaxen och exempel på slutligen blockering.
Den allmänna syntaxen för det slutliga blocket är som följer:
try { //code that might raise exception }catch { //code that handles exception }finally { //mandatory code to be executed }Även om blocket slutligen alltid körs, finns det vissa situationer eller fall där det inte körs.
Dessa är följande fall:
- När tråden är död.
- När metoden System.exit () används.
- När ett undantag inträffar i slutblocket.
Låt oss implementera ett par program för att visa det slutliga blocket.
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...'); } } Produktion
Ovanstående program visar ett försök-fång-slut-block. I försöksblocket utförs en giltig operation och därför kastas inget undantag. Därför överförs inte kontrollen för att fånga från försök utan för att slutligen blockera.
Följande program är ett annat exempel på try-catch-slut-block men i det här fallet kastas undantaget i försöksblocket när vi utför en delning med noll-operation. Sålunda exekveras slutligen blocket efter försöket att fångstblocket körs.
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...'); } } Produktion
verktyg för prestandatestning för Java-applikationer
Kasta ett undantag i Java
Java tillhandahåller ett nyckelord 'kast' med vilket vi uttryckligen kan kasta undantagen i koden. Till exempel, om vi kontrollerar aritmetiska operationer och vill höja några undantag efter att ha kontrollerat operander kan vi göra det med nyckelordet 'kast'.
Med hjälp av kasta nyckelordet kan vi kasta de markerade eller okontrollerade undantagen. Kasta nyckelordet används också för att kasta anpassade undantag.
Den allmänna syntaxen för kastnyckelordet är:
throw exception; or throw new exception_class('error message'); Nedan ges ett exempel på ett program för att visa kastordet.
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...'); } } Produktion
I ovanstående program använder vi en metod för att validera ålder. Om ålder är<18, then an exception is thrown to indicate the age is not valid.
Kastar klausul
Vi har sett försök blockera för att förklara undantag. Den innehåller koden som kan leda till undantag. Det finns ett annat sätt att förklara ett undantag och det använder nyckelordet 'kastar'.
Undantagsförklaringen med nyckelordet 'kastar' säger till programmeraren att det kan finnas ett undantag som anges efter 'kast' -nyckelordet och programmeraren bör tillhandahålla motsvarande hanteringskod för detta undantag för att bibehålla det normala flödet av programmet.
Frågan uppstår dock varför vi behöver ett 'kastar' -nyckelord när vi har ett mer tillförlitligt försöksfångstblock för att förklara och hantera undantag?
En anledning är när antalet undantag som kan komma att öka ökar, antalet fångstblock som hanterar undantag ökar också eftersom ett fångstblock bara kan hantera ett undantag.
På samma sätt, om det finns många metoder i ett program och varje metod har många undantag kommer koden att bli onödigt lång och ohanterlig.
Således att förklara ett undantag med kastord i nyckelordet i metodens signatur och sedan hantera metodanropet med try-catch verkar vara en livskraftig lösning.
En annan fördel med att förklara undantag med hjälp av kastord är att vi tvingas hantera undantagen. Om vi inte tillhandahåller en hanterare för ett deklarerat undantag kommer programmet att ta upp ett fel.
Den allmänna syntaxen för kastnyckelordet är som följer:
return_type method_name() throws exception_class_name{ //method code } Låt oss nu implementera ett Java-program för att visa nyckelordet “kastar”.
I det här programmet har vi en klass Exempel_kast där vi har en metod testMethod. I signaturen för detta testMethod förklarar vi två undantag IOException och Arithmetic Exception med hjälp av kast-nyckelordet. Sedan i huvudfunktionen hanteras undantagen som kastas av fångsten.
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); } } }Produktion
Vanliga frågor
F # 1) När ska jag kasta VS-försök i Java?
Svar: Nyckelordet “kastar” används för att deklarera undantaget med metodens signatur. Kasta nyckelordet används för att uttryckligen kasta undantaget. Try-catch-blocket används för att hantera undantag från andra.
F # 2) Kan vi använda kast, försöka fånga i en enda metod?
Svar: Nej. Du kan inte kasta undantaget och fånga det på samma sätt. Undantaget som deklareras med hjälp av kast ska hanteras i anropsmetoden som kallar metoden som har kastat undantaget.
F # 3) Vad händer när ett fångstblock ger ett undantag?
Svar: När ett undantag kastas i fångsten blockerar programmet körningen. Om programmet måste fortsätta måste det finnas ett separat försöksfångstblock för att hantera undantaget som tas upp i fångstblocket.
F # 4) Vad är försök-fånga-slutligen i Java?
Svar: Try-catch-slut-blocket innehåller de tre blocken, dvs. försök blockera, fånga block och slutligen blockera.
Försök block innehåller koden som kan orsaka ett undantag. Fångstblock innehåller undantagshanteraren för undantag i försöksblocket. Det slutliga blocket innehåller den kritiska koden som kommer att köras oavsett om undantaget har inträffat eller inte.
F # 5) Kan äntligen blockera försök-fångst?
Svar: Ja, om vi har en saneringskod som kan kasta ett undantag i det slutliga blocket, kan vi ha ett försök-fångstblock. Det ser dock ful ut.
Slutsats
I denna handledning diskuterade vi de olika nyckelorden som används vid undantagshantering i Java. Vi har diskuterat nyckelorden som försök, fånga, äntligen, kasta och kasta.
Koden som möjligen kommer att kasta ett undantag finns i försöksblocket och fångsten ger hanteraren för undantaget. Det slutliga blocket kör koden i den oavsett om undantaget kastas eller inte. Slutligen följer blocket i allmänhet försök eller försök-fångst-blocket.
Vi använder nyckelordet för att förklara undantag med metodens signatur och kast används uttryckligen för att kasta undantag. Vi använder vanligtvis throw-nyckelord för att kasta anpassade undantag.
=> Kolla in den perfekta Java-träningsguiden här.
Rekommenderad läsning
- Java-undantag och undantagshantering med exempel
- Hur hanterar jag ArrayIndexOutOfBoundsException i Java?
- JAVA-handledning för nybörjare: 100+ praktiska Java-videohandledning
- JDBC Undantagshantering - Hur man hanterar SQL-undantag
- C # Exception Handling Tutorial med kodexempel
- Komplett guide till PL SQL-undantagshantering med exempel
- Undantagshantering i C ++
- Python Prova utom - Python-hanteringsundantag med exempel