try catch finally
I denne vejledning diskuterer vi forskellige nøgleord, der bruges i Java til undtagelseshåndtering som Try, Catch, Endelig, Kast og kast med eksempler:
I vores tidligere tutorials har vi set det grundlæggende i undtagelseshåndtering i Java sammen med de forskellige undtagelser, der understøttes af Java Exception-klassen. Vi diskuterede også NullPointerException i detaljer.
Vi kan medtage undtagelser i vores program ved at bruge bestemte nøgleord, der findes i Java. Disse nøgleord definerer forskellige kodeblokke, der letter definition og håndtering af undtagelser.
=> Besøg her for den eksklusive Java-træningsundervisningsserie.
Hvad du lærer:
Prøv, fang, endelig i Java
Nedenstående nøgleord bruges i Java til håndtering af undtagelser.
- Prøve
- Fangst
- Langt om længe
- Kaste
- Kaster
Følgende tabel beskriver kort disse nøgleord.
| Nøgleord | Beskrivelse |
|---|---|
| Prøve | Vi specificerer den kodeblok, der kan give anledning til undtagelsen i en speciel blok med et 'Prøv' nøgleord. |
| Fangst | Når undtagelsen hæves, skal den fanges af programmet. Dette gøres ved hjælp af et 'fange' nøgleord. Så en fangstblok følger prøveblokken, der giver en undtagelse. Nøgleordet fangst skal altid bruges med et forsøg. |
| Langt om længe | Nogle gange har vi en vigtig kode i vores program, der skal udføres, uanset om undtagelsen kastes eller ej. Denne kode placeres i en speciel blok, der starter med nøgleordet 'Endelig'. Den sidste blok følger Try-catch-blokken. |
| Kaste | Nøgleordet 'kast' bruges til at udtrykke undtagelsen eksplicit. |
| Kaster | Nøgleordet 'Kast' kaster ikke en undtagelse, men bruges til at erklære undtagelser. Dette nøgleord bruges til at angive, at der kan forekomme en undtagelse i programmet eller metoden. |
I denne vejledning vil vi diskutere alle ovenstående nøgleord i detaljer sammen med programmeringseksemplerne.
Prøv at blokere i Java
Når vi skriver et program, kan der være en kode, som vi har mistanke om, kan give en undtagelse. For eksempel, vi har måske mistanke om, at der muligvis er en 'division med nul' -operation i koden, der vil give en undtagelse.
Denne kode, der muligvis hæver en undtagelse, er lukket i en blok med nøgleordet 'prøv'. Så prøveblokken indeholder koden eller sæt sætninger, der kan skabe en undtagelse.
Den generelle syntaks for prøveblokken er som følger:
try{ //set of statements that can raise exception } Derfor, hvis en programmør mener, at visse udsagn vil medføre undtagelser, skal du vedlægge disse udsagn i en prøveblok. Bemærk, at når en undtagelse forekommer ved en bestemt sætning i en prøveblok, så udføres resten af koden ikke.
Når en undtagelse forekommer i en prøveblokering ved en bestemt erklæring, kommer kontrollen ud, og programmet afsluttes pludseligt. For at forhindre denne pludselige afslutning af programmet skal vi 'håndtere' denne undtagelse. Denne håndtering udføres ved hjælp af nøgleordet 'fangst'. Så en prøveblok har altid en fangstblok efter den.
Catch Block i Java
Vi bruger en fangstblok til at håndtere undtagelser. Dette er blokken med 'fangst' nøgleordet. Fangsblokken følger prøveblokken.
Hver gang der forekommer en undtagelse i prøveblokken, udføres koden i fangstblokken, der svarer til undtagelsen.
Den generelle syntaks for fangstblokken er:
catch (Exception e){ //code to handle exception e }Generelt skal den erklærede undtagelse være overordnet klasse for alle undtagelser, dvs. undtagelse. Men hvis der er mere end en undtagelse, kan vi også skrive specifikke undtagelsestyper eller genererede undtagelser.
Dernæst vil vi diskutere forsøge-blok. Bemærk, at for hver prøveblok kan vi have flere fangstblokke.
Prøv at fange Java
Den generelle syntaks for try-catch-blokken vises nedenfor:
try{ //code causing exception } catch (exception (exception_type) e (object)) { //exception handling code }Prøveblokken kan have flere kodelinjer, der kan hæve flere undtagelser. Hver af disse undtagelser håndteres af en uafhængig fangstblok.
Den generiske undtagelsesbehandler, objekt e i klasse Undtagelse kan håndtere alle undtagelser, men hvis vi vil håndtere specifikke undtagelser, anbefales det at specificere den generiske undtagelsesbehandler som den sidste fangstblok.
Java Prøv fangsteksempel
Lad os nu demonstrere en prøvefangst-blok i Java. Her i prøveblokken definerer vi en opdeling. Deleren er nul. Således rejser udsagnet, der deler de to tal, en aritmetisk undtagelse. Vi har en fangeblok, der definerer en handler til aritmetisk undtagelse.
Nedenfor er et eksempel på et 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
hvad er forskellen mellem unix og linux
Fange flere undtagelser
Som allerede nævnt kan en prøveblok indeholde en kode, der rejser mere end en undtagelse. I dette tilfælde har vi brug for mere end en fangstblok for at håndtere hver undtagelse. En enkelt prøveblok kan efterfølges af flere fangstblokke. Hver fangstblok håndterer de uafhængige undtagelser.
I tilfælde af flere fangstblokke skal vi huske nedenstående punkter:
- I et Java-program kan der til enhver tid kun forekomme en undtagelse. Også på ethvert tidspunkt udføres kun en fangstblok.
- De flere fangstblokke skal bestilles på en sådan måde, at fangstblokken for den mest specifikke undtagelse skal komme først og derefter den generelle.
For eksempel, hvis vi har ArithmeticException og generel undtagelse, så kommer fangstblokhåndtering ArithmeticException først efterfulgt af fangstblokhåndtering Exception.
Eksemplet nedenfor viser flere fangstblokke.
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 ovenstående program hæves et ArithmeticException, der er fanget i den første fangstblok. Hvis denne fangstblok ikke blev specificeret, ville undtagelsen have spredt sig til den generelle fangstblok.
Lad os ændre det ovennævnte program lidt, så prøveblokken hæver to undtagelser. Lad os nu se output.
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
Hvis vi ser denne output, viser den, at ArrayIndexOutOfBoundsException kastes. Dette skyldes, at udsagnet, der rejser ArrayIndexOutOfBoundsException, udføres først. Undtagelsen kastes, og kontrollen går til den tilsvarende fangeblok.
Indlejret Try-Catch
En prøveblok inde i en anden prøveblok kaldes en indlejret prøveblok. Vi har brug for sådanne strukturer i visse situationer, når et stykke kode indeholdt i en prøvekode kan være sådan, at nogle linjer hæver visse undtagelser, og et andet stykke kode giver en helt anden undtagelse.
I tilfælde af indlejrede prøveblokke udføres først den inderste prøveblok, og undtagelsen håndteres. Hvis den inderste prøveblok ikke har en matchende fangstblok, formeres den et niveau op til dens overordnede prøveblok. På denne måde forplantes undtagelsen opad indtil matchende undtagelseshåndterer findes.
Hvis der ikke er nogen undtagelsesbehandler, der matcher undtagelsen, afsluttes programmet brat med en systemgenereret meddelelse.
Den generelle syntaks for en indlejret prøveblok er angivet nedenfor:
try { //try_block 1; try { //try_block 2; } catch(Exception e) { //exception handler code } } catch(Exception e) { //exception handler code }Lad os implementere et program til at demonstrere den indlejrede try-catch-blok.
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 ovenstående program har vi to forsøgsblokke indeholdt i hovedforsøgsblokken. Begge de indre prøveblokke har en kode, der hæver ArithmeticException. Men vi har kun leveret en matchende fangstblok til den første blok og ikke til den anden prøveblok.
Derfor udbreder den anden blok sin undtagelse fra hovedforsøgsblokken og håndterer den derefter. Dette fremgår af output.
Endelig blokere i Java
Indtil videre har vi set try-catch og nestet prøveblok. Vi ved, at den kode, der forventes at hæve undtagelsen, er sat i en prøveblok. Når en undtagelse opstår, udføres resten af koden i prøveblokken ikke.
Enten afsluttes programmet brat, hvis en undtagelse ikke håndteres, eller kontrollen videregives til undtagelsesbehandleren.
I en sådan situation opstår der et behov for at inkludere en kode, der skal udføres, uanset om der forekommer en undtagelse eller ej. Dette betyder, at vi udfører et stykke kode, selv når en undtagelse forekommer, og også når undtagelsen ikke forekommer.
Men da prøveblokudgange efter undtagelsen er hævet, kan vi ikke placere denne kode i prøveblokken. Tilsvarende har fangstblok en undtagelsesbehandler, så vi kan ikke placere denne også i fangstblokken.
Således har vi brug for en separat blok, der indeholder en kode, der udføres, uanset om der forekommer en undtagelse eller ej. Java giver en 'endelig' blok, der indeholder dette stykke kode.
Derfor kan en endelig blokering i Java indeholde kritiske udsagn, der skal udføres i programmet. Udførelsen af disse erklæringer skal udføres, selv når en undtagelse forekommer eller ej.
Derfor placerer vi kode som lukning af forbindelser, stream-objekter osv. Eller enhver oprydningskode i den endelige blok, så de kan udføres, selvom der forekommer en undtagelse.
Den endelige blok i Java placeres normalt efter en prøve- eller fangstblok. Bemærk, at den endelige blok ikke kan eksistere uden en prøveblok. Når den endelige blok er inkluderet i try-catch, bliver det en ” prøv-fang-endelig ”Blok.
Vi kan springe over den endelig blok i undtagelseshåndteringskode. Dette betyder, at endelig blokering er valgfri.
Hvis prøveblokken ikke hæver nogen undtagelse, vil den endelige blok blive udført efter prøveblokken. Hvis der er en undtagelse i prøveblokken, overføres kontrollen til fangstblokken først og derefter til sidst blokken.
En undtagelse, der forekommer i endelig blok, opfører sig på samme måde som enhver anden undtagelse. Selvom prøveblokken indeholder returerklæring eller forgreningserklæringer som pause og fortsættelse, vil den endelige blok stadig blive udført.
Når vi holder disse punkter i tankerne, fortsætter vi med den generelle syntaks og eksempler på endelig blokering.
Den generelle syntaks for den endelige blok er som følger:
try { //code that might raise exception }catch { //code that handles exception }finally { //mandatory code to be executed }Selvom blok endelig altid udføres, er der visse situationer eller tilfælde, hvor den ikke udføres.
Dette er nedenstående tilfælde:
- Når tråden er død.
- Når metoden System.exit () bruges.
- Når der forekommer en undtagelse i den endelige blok.
Lad os implementere et par programmer for at demonstrere den endelige blokering.
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
Ovenstående program viser en prøve-fangst-endelig blokering. I prøveblokken udføres en gyldig operation, og der kastes ingen undtagelse. Derfor overføres kontrollen ikke til at fange fra forsøg, men til sidst at blokere.
Det følgende program er et andet eksempel på try-catch-finally-blok, men i dette tilfælde kastes undtagelsen i prøveblokken, da vi udfører en division med nul-operation. Således udføres den endelige blok efter forsøget fangstblokken udføres.
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
Kast en undtagelse i Java
Java giver et nøgleord 'kaste' ved hjælp af hvilket vi eksplicit kan kaste undtagelserne i koden. For eksempel, hvis vi kontrollerer aritmetiske operationer og ønsker at hæve nogle undtagelser efter kontrol af operander, kan vi gøre det ved hjælp af 'kaste' nøgleordet.
Ved hjælp af kaste nøgleordet kan vi kaste de markerede eller ikke-markerede undtagelser. Kast nøgleordet bruges også til at kaste brugerdefinerede undtagelser.
Den generelle syntaks for kast nøgleordet er:
throw exception; or throw new exception_class('error message'); Nedenfor er et eksempel på et program, der viser demonstrationsnøgleordet.
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 ovenstående program bruger vi en metode til at validere alder. Hvis alderen er<18, then an exception is thrown to indicate the age is not valid.
Kaster klausul
Vi har set prøve blokere for at erklære undtagelser. Den indeholder den kode, der kan give undtagelser. Der er en anden måde at erklære en undtagelse på, og det bruger søgeordet 'kaster'.
Undtagelseserklæringen ved hjælp af 'kaster' nøgleordet fortæller programmøren, at der kan være en undtagelse, der er angivet efter 'kaster' nøgleordet, og programmøren skal give den tilsvarende håndteringskode til denne undtagelse for at opretholde den normale strøm af programmet.
Spørgsmålet opstår imidlertid, hvorfor vi har brug for et 'kaster' nøgleord, når vi har en mere pålidelig prøvefangstblok til at erklære og håndtere undtagelser?
oracle sql interview spørgsmål til erfarne
Én årsag er, da antallet af undtagelser, der muligvis kan forekomme, øges, antallet af fangstblok, der håndterer undtagelser, også øges, da en fangstblok kun kan håndtere en undtagelse.
Tilsvarende, hvis der er mange metoder i et program, og hver metode har adskillige undtagelser, bliver koden unødigt lang og uhåndterbar.
Således at erklære en undtagelse med kaster nøgleord i metodesignaturen og derefter håndtere metodekaldet ved hjælp af try-catch synes at være en levedygtig løsning.
En anden fordel ved at erklære undtagelser ved hjælp af kasterord er, at vi er tvunget til at håndtere undtagelserne. Hvis vi ikke leverer en handler til en erklæret undtagelse, vil programmet rejse en fejl.
Den generelle syntaks for kasterordet er som følger:
return_type method_name() throws exception_class_name{ //method code } Lad os nu implementere et Java-program for at demonstrere nøgleordet 'kaster'.
I dette program har vi en klasse Example_throw, hvor vi har en metode testMethod. I signaturen til denne testMethode erklærer vi to undtagelser IOException og Arithmetic Exception ved hjælp af kaster-nøgleordet. Derefter håndteres de kastede undtagelser i hovedfunktionen af fangstblokken.
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
Ofte stillede spørgsmål
Spørgsmål nr. 1) Hvornår skal jeg kaste kaste VS prøvefangst i Java?
Svar: Nøgleordet 'kaster' bruges til at erklære undtagelsen med metodesignaturen. Kast nøgleordet bruges til eksplicit at kaste undtagelsen. Try-catch-blokken bruges til at håndtere de undtagelser, som andre har kastet.
Spørgsmål nr. 2) Kan vi bruge kast, prøve at fange i en enkelt metode?
Svar: Nej. Du kan ikke smide undtagelsen og også fange den på samme måde. Den undtagelse, der erklæres ved hjælp af kast, skal håndteres i den kaldemetode, der kalder den metode, der har kastet undtagelsen.
Spørgsmål nr. 3) Hvad sker der, når en fangstblok giver en undtagelse?
Svar: Når en undtagelse kastes i fangstblokken, stopper programmet udførelsen. Hvis programmet skal fortsætte, skal der være en separat prøvefangerblok for at håndtere den undtagelse, der er rejst i fangstblokken.
Spørgsmål nr. 4) Hvad er endelig prøve-fangst i Java?
Svar: Try-catch-slut-blokken indeholder de tre blokke, dvs. prøv blok, fang blok og endelig blok.
Prøv blok indeholder den kode, der muligvis kaster en undtagelse. Fangstblok indeholder undtagelsesbehandleren for undtagelser i prøveblokken. Den endelige blok indeholder den kritiske kode, der udføres uanset om undtagelsen er sket eller ej.
Q # 5) Kan endelig blokere have try-catch?
Svar: Ja, hvis vi har en oprydningskode, der muligvis kaster en undtagelse i den endelige blok, så kan vi have en prøvefangst-blok. Det ser dog grimt ud.
Konklusion
I denne vejledning diskuterede vi de forskellige nøgleord, der blev brugt til undtagelseshåndtering i Java. Vi har diskuteret nøgleordene som prøve, fange, endelig, kaste og kaste.
Koden, der muligvis vil kaste en undtagelse, er vedlagt i prøveblokken, og fangsten giver handlen for undtagelsen. Den endelige blok udfører koden indeholdt i den, uanset om undtagelsen kastes eller ej. Den endelige blok følger generelt forsøgs- eller forsøg-fang-blokken.
Vi bruger kaster-nøgleordet til at erklære undtagelser med metodesignaturen, og kast bruges eksplicit til at kaste undtagelser. Vi bruger normalt kaste nøgleord til at kaste brugerdefinerede undtagelser.
=> Tjek den perfekte Java-træningsvejledning her.
Anbefalet læsning
- Java-undtagelser og undtagelseshåndtering med eksempler
- Sådan håndteres ArrayIndexOutOfBoundsException i Java?
- JAVA-vejledning til begyndere: 100+ praktiske Java-videovejledninger
- JDBC-undtagelseshåndtering - Sådan håndteres SQL-undtagelser
- C # Exception Handling Tutorial med kodeeksempler
- Komplet guide til PL SQL undtagelseshåndtering med eksempler
- Undtagelseshåndtering i C ++
- Python Prøv undtagen - Pythonhåndteringsundtagelse med eksempler