try catch finally
I denne opplæringen vil vi diskutere forskjellige nøkkelord som brukes i Java for unntakshåndtering som Try, Catch, Endelig, Throw og Throw med eksempler:
I våre tidligere veiledninger har vi sett det grunnleggende om unntakshåndtering i Java sammen med de forskjellige unntakene som støttes av Java Exception-klassen. Vi diskuterte også NullPointerException i detalj.
Vi kan inkludere unntak i programmet vårt ved å bruke visse nøkkelord som er gitt i Java. Disse søkeordene definerer forskjellige kodeblokker som letter definering og håndtering av unntak.
=> Besøk her for den eksklusive opplæringsserien for Java Training.
Hva du vil lære:
Prøv, fang, til slutt i Java
Nøkkelordene nedenfor brukes i Java for håndtering av unntak.
- Prøve
- Å fange
- Endelig
- Kaste
- Kaster
Tabellen nedenfor beskriver disse nøkkelordene kort.
Nøkkelord | Beskrivelse |
---|---|
Prøve | Vi spesifiserer kodeblokken som kan gi unntak i en spesiell blokk med et 'søkeord'. |
Å fange | Når unntaket heves, må det fanges opp av programmet. Dette gjøres ved hjelp av et 'fange' nøkkelord. Så en fangstblokk følger prøveblokken som gir et unntak. Nøkkelordet fangst bør alltid brukes med et forsøk. |
Endelig | Noen ganger har vi en viktig kode i programmet vårt som må utføres uavhengig av om unntaket blir kastet eller ikke. Denne koden plasseres i en spesiell blokk som begynner med søkeordet 'Endelig'. Den siste blokken følger Try-catch-blokken. |
Kaste | Nøkkelordet 'kaste' brukes til å kaste unntaket eksplisitt. |
Kaster | Nøkkelordet 'kaster' kaster ikke noe unntak, men brukes til å erklære unntak. Dette nøkkelordet brukes til å indikere at et unntak kan forekomme i programmet eller metoden. |
I denne opplæringen vil vi diskutere alle de ovennevnte søkeordene i detalj sammen med programmeringseksemplene.
Prøv å blokkere i Java
Hver gang vi skriver et program, kan det være en kode som vi mistenker kan gi et unntak. For eksempel, vi kan mistenke at det kan være en 'divisjon med null' -operasjon i koden som vil gi et unntak.
Denne koden som kan gi et unntak er lukket i en blokk med nøkkelordet 'prøv'. Så prøveblokken inneholder koden eller settet med utsagn som kan gi et unntak.
Den generelle syntaksen for prøveblokken er som følger:
try{ //set of statements that can raise exception }
Derfor, hvis en programmerer mener at visse utsagn vil gi unntak, så legg disse utsagnene til i en prøveblokk. Merk at når et unntak oppstår ved en spesifikk setning i en prøveblokk, så blir ikke resten av koden utført.
Når et unntak oppstår i en prøveblokk på en bestemt uttalelse, kommer kontrollen ut og programmet avsluttes brått. For å forhindre denne brå avslutningen av programmet, bør vi “håndtere” dette unntaket. Denne håndteringen gjøres ved å bruke søkeordet 'fangst'. Så en prøveblokk har alltid en fangstblokk som følger den.
Fangstblokk i Java
Vi bruker en fangstblokk for å håndtere unntak. Dette er blokken med søkeordet 'fangst'. Fangsblokken følger prøveblokken.
Hver gang det oppstår et unntak i prøveblokken, blir koden i fangstblokken som tilsvarer unntaket utført.
Den generelle syntaksen til fangstblokken er:
catch (Exception e){ //code to handle exception e }
Generelt sett må det erklærte unntaket være overordnet klasse for alle unntak, dvs. unntak. Men hvis det er mer enn ett unntak, kan vi også skrive spesifikke unntakstyper eller genererte unntak.
Deretter vil vi diskutere prøvefangstblokken. Merk at for hver prøveblokk kan vi ha flere fangstblokker.
Prøv å fange Java
Den generelle syntaksen for prøvefangstblokken er vist nedenfor:
try{ //code causing exception } catch (exception (exception_type) e (object)) { //exception handling code }
Prøveblokken kan ha flere kodelinjer som kan øke flere unntak. Hvert av disse unntakene håndteres av en uavhengig fangstblokk.
Den generiske unntakshåndtereren, objekt e i Exception-klassen kan håndtere alle unntakene, men hvis vi ønsker å håndtere spesifikke unntak, er det tilrådelig å spesifisere den generiske unntakshåndtereren som den siste fangstblokken.
Java Prøv fangsteksempel
La oss nå demonstrere en prøvefangstblokk i Java. Her i prøveblokken definerer vi en divisjonsoperasjon. Deleren er null. Således gir uttalelsen som deler de to tallene et aritmetisk unntak. Vi har en fangstblokk som definerer en behandler for aritmetisk unntak.
Nedenfor er et eksempel 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.'); } }
Produksjon
hvordan du kjører .jar-filer på Windows
Fange flere unntak
Som allerede nevnt kan en prøveblokk inneholde en kode som gir mer enn ett unntak. I dette tilfellet trenger vi mer enn en fangstblokk for å håndtere hvert unntak. En enkelt prøveblokk kan følges av flere fangstblokker. Hver fangstblokk vil håndtere de uavhengige unntakene.
Når det gjelder flere fangstblokker, må vi huske punktene nedenfor:
- I et Java-program, når som helst, kan bare ett unntak forekomme. Også når som helst blir bare en fangstblokk utført.
- Flere fangstblokker bør bestilles på en slik måte at fangstblokken for det mest spesifikke unntaket skal komme først og deretter generalen.
For eksempel, hvis vi har ArithmeticException og generelt unntak, vil fangstblokkhåndteringen ArithmeticException komme først etterfulgt av fangstblokkhåndteringen Exception.
Eksemplet nedenfor viser flere fangstblokker.
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'); } }
Produksjon
I programmet ovenfor heves et aritmetisk unntak som er fanget i den første fangstblokken. Hvis denne fangstblokken ikke ble spesifisert, ville unntaket ha spredt seg til den generelle fangstblokken.
La oss modifisere programmet ovenfor, slik at prøveblokken gir to unntak. La oss nå 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'); } }
Produksjon
Hvis vi ser denne utgangen, viser den at ArrayIndexOutOfBoundsException blir kastet. Dette er fordi uttalelsen som reiser ArrayIndexOutOfBoundsException blir utført først. Unntaket kastes og kontrollen går til tilsvarende fangstblokk.
Nestet Try-Catch
En prøveblokk inne i en annen prøveblokk kalles en nestet prøveblokk. Vi trenger slike strukturer i visse situasjoner når en kode som finnes i en prøvekode kan være slik at noen linjer hever visse unntak, og en annen kode gir et helt annet unntak.
I tilfelle nestede prøveblokker utføres først den innerste prøveblokken og unntaket håndteres. Hvis den innerste prøveblokken ikke har en samsvarende fangstblokk, forplantes den ett nivå opp til den overordnede prøveblokken. På denne måten blir unntaket forplantet oppover til samsvarende unntaksbehandler blir funnet.
Hvis det ikke er noen unntaksbehandler som samsvarer med unntaket, avsluttes programmet brått med en systemgenerert melding.
Den generelle syntaksen til en nestet prøveblokk er gitt nedenfor:
try { //try_block 1; try { //try_block 2; } catch(Exception e) { //exception handler code } } catch(Exception e) { //exception handler code }
La oss implementere et program for å demonstrere den nestede prøvefangstblokken.
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'); } }
Produksjon
I programmet ovenfor har vi to prøveblokker som er lukket i hovedforsøksblokken. Begge de indre prøveblokkene har en kode som hever ArithmeticException. Men vi har gitt en matchende fangstblokk bare for den første blokken og ikke for den andre forsøksblokken.
Derfor forplanter den andre blokken sitt unntak fra hovedforsøksblokken og håndterer den deretter. Dette fremgår av produksjonen.
Endelig blokkere Java
Så langt har vi sett prøvefanger og nestet prøveblokk. Vi vet at koden som forventes å heve unntaket er satt i en prøveblokk. Når et unntak oppstår, blir ikke resten av koden i prøveblokken utført.
Enten avslutter programmet brått hvis et unntak ikke håndteres eller kontrollen overføres til unntaksbehandleren.
I en slik situasjon oppstår det et behov for å inkludere en kode som skal utføres uavhengig av om det oppstår et unntak eller ikke. Dette betyr at vi vil utføre et stykke kode selv når et unntak oppstår og også når unntaket ikke forekommer.
Men ettersom prøveblokkutganger etter at unntaket er hevet, kan vi ikke sette denne koden i prøveblokken. På samme måte har fangstblokk en unntakshåndterer, så vi kan ikke plassere dette i fangstblokken også.
Dermed trenger vi en egen blokk som inneholder en kode som kjøres uavhengig av om det oppstår et unntak eller ikke. Java gir en 'endelig' blokk som inneholder denne delen av koden.
Derfor kan en endelig blokk i Java inneholde kritiske utsagn som skal utføres i programmet. Utførelsen av disse uttalelsene bør utføres selv når et unntak oppstår eller ikke.
Derfor vil vi sette kode som å lukke forbindelser, streame objekter osv. Eller hvilken som helst oppryddingskode i den endelige blokken, slik at de kan utføres selv om et unntak oppstår.
Den endelige blokken i Java blir vanligvis satt etter en prøve- eller fangstblokk. Merk at den endelige blokken ikke kan eksistere uten en prøveblokk. Når den endelige blokken er inkludert i prøvefangst, blir det en “ prøv-fang-endelig ”Blokk.
Vi kan hoppe over den endelige blokkeringen i unntakshåndteringskoden. Dette betyr at endelig blokk er valgfritt.
Hvis prøveblokken ikke gir noe unntak, vil den endelige blokken utføres etter prøveblokken. Hvis det er et unntak i prøveblokken, vil kontrollen passere til fangstblokken først og deretter til sluttblokken.
Et unntak som oppstår i endelig blokk oppfører seg på samme måte som ethvert annet unntak. Selv om prøveblokken inneholder returuttalelser eller forgreningsuttalelser som pause og fortsett, vil den endelige blokken fortsatt bli utført.
Med tanke på disse punktene fortsetter vi med den generelle syntaksen og eksempler på endelig blokk.
Den generelle syntaksen til den endelige blokken er som følger:
try { //code that might raise exception }catch { //code that handles exception }finally { //mandatory code to be executed }
Selv om til slutt alltid utføres blokk, er det visse situasjoner eller tilfeller der den ikke utføres.
Dette er tilfellene nedenfor:
- Når tråden er død.
- Når System.exit () -metoden brukes.
- Når et unntak oppstår i den endelige blokken.
La oss implementere et par programmer for å demonstrere den endelige blokkeringen.
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...'); } }
Produksjon
Ovennevnte program viser en prøve-fang-til slutt-blokk. I prøveblokken utføres en gyldig operasjon, og det blir ikke kastet noe unntak. Derfor blir ikke kontrollen overført for å fange fra prøve, men til slutt å blokkere.
sql scenariobaserte spørsmål og svar
Følgende program er et annet eksempel på try-catch-finally-blokk, men i dette tilfellet kastes unntaket i prøveblokken når vi utfører en divisjon med null-operasjon. Dermed blir den endelige blokken utført etter forsøket fangstblokken er utført.
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...'); } }
Produksjon
Kast et unntak i Java
Java gir et nøkkelord 'kast' ved hjelp av hvilket vi eksplisitt kan kaste unntakene i koden. For eksempel, hvis vi sjekker aritmetiske operasjoner og ønsker å heve noen unntak etter å ha sjekket operander, kan vi gjøre det ved hjelp av 'kast' nøkkelordet.
Ved å bruke kast-nøkkelordet kan vi kaste de avmerkede eller ukontrollerte unntakene. Kast-nøkkelordet brukes også til å kaste tilpassede unntak.
Den generelle syntaksen for kastesøkeordet er:
throw exception; or throw new exception_class('error message');
Nedenfor er et eksempel på et program for å demonstrere kastesøkeordet.
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...'); } }
Produksjon
I programmet ovenfor bruker vi en metode for å validere alder. Hvis alderen er<18, then an exception is thrown to indicate the age is not valid.
Kaster klausul
Vi har sett prøveblokkering for å erklære unntak. Den inneholder koden som kan gi unntak. Det er en annen måte å erklære et unntak på, og det er å bruke nøkkelordet 'kaster'.
Unntakserklæringen ved å bruke 'kaster' nøkkelordet forteller programmereren at det kan være et unntak spesifisert etter 'kaster' nøkkelordet, og programmereren bør oppgi tilsvarende håndteringskode for dette unntaket for å opprettholde den normale flyt av programmet.
Spørsmålet oppstår imidlertid hvorfor vi trenger et 'kast' -nøkkelord når vi har en mer pålitelig prøvefangstblokk for å erklære og håndtere unntak?
En årsak er ettersom antall unntak som kan oppstå øker, antall fangstblokker som håndterer unntak øker også ettersom en fangstblokk bare kan håndtere ett unntak.
På samme måte, hvis det er mange metoder i et program og hver metode har mange unntak, vil koden bli unødvendig lang og uhåndterlig.
Dermed å erklære et unntak med kaster nøkkelord i metodesignaturen og deretter håndtere metodeanropet ved hjelp av prøvefangst, ser det ut til å være en levedyktig løsning.
En annen fordel med å erklære unntak ved å bruke kasteord er at vi er tvunget til å håndtere unntakene. Hvis vi ikke gir en behandler for et erklært unntak, vil programmet føre til en feil.
Den generelle syntaksen for kasteordet er som følger:
return_type method_name() throws exception_class_name{ //method code }
La oss nå implementere et Java-program for å demonstrere nøkkelordet 'kaster'.
I dette programmet har vi en klasse Example_throw der vi har en metodetestMethod. I signaturen til denne testmetoden erklærer vi to unntak IO-unntak og aritmetisk unntak ved å bruke kaste-nøkkelordet. Så i hovedfunksjonen håndteres unntakene som kastes av 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); } } }
Produksjon
ofte stilte spørsmål
Spørsmål nr. 1) Når skal jeg kaste VS prøvefangst i Java?
Svar: Nøkkelordet 'kaster' brukes til å erklære unntaket med metodesignaturen. Kast-nøkkelordet brukes til å eksplisitt kaste unntaket. Try-catch-blokken brukes til å håndtere unntakene som kastes av andre.
Spørsmål 2) Kan vi bruke kast, prøve å fange i en enkelt metode?
Svar: Nei. Du kan ikke kaste unntaket og også fange det på samme måte. Unntaket som er erklært ved hjelp av kast, skal håndteres i anropsmetoden som kaller metoden som har kastet unntaket.
Sp # 3) Hva skjer når en fangstblokk gir et unntak?
Svar: Når et unntak kastes i fangstblokken, stopper programmet utførelsen. Hvis programmet må fortsette, må det være en egen prøvefangstblokk for å håndtere unntaket hevet i fangstblokken.
Spørsmål nr. 4) Hva er try-catch-endelig i Java?
Svar: Try-catch-finally-blokken inneholder de tre blokkene, dvs. prøv blokker, fang blokker og til slutt blokker.
Prøveblokk inneholder koden som kan gi unntak. Fangsblokk inneholder unntaksbehandler for unntak i prøveblokken. Den endelige blokken inneholder den kritiske koden som vil kjøres uavhengig av om unntaket har skjedd eller ikke.
Q # 5) Kan endelig blokkere ha prøvefangst?
Svar: Ja, hvis vi har en oppryddingskode som kan kaste et unntak i den endelige blokken, så kan vi ha en prøvefangstblokk. Det ser imidlertid stygt ut.
Konklusjon
I denne opplæringen diskuterte vi de forskjellige nøkkelordene som ble brukt i unntaksbehandling i Java. Vi har diskutert nøkkelordene som prøve, fange, til slutt, kaste og kaste.
Koden som muligens vil kaste et unntak, er vedlagt i prøveblokken, og fangsten gir føreren for unntaket. Den endelige blokken utfører koden som er vedlagt i den, uansett om unntaket blir kastet eller ikke. Den endelige blokken følger vanligvis prøve- eller prøv-fang-blokken.
Vi bruker kaste-nøkkelordet for å erklære unntak med metodesignaturen og kaste brukes eksplisitt for å kaste unntak. Vi bruker vanligvis kaste nøkkelord for å kaste tilpassede unntak.
=> Ta en titt på den perfekte Java-treningsveiledningen her.
Anbefalt lesing
- Java-unntak og unntakshåndtering med eksempler
- Hvordan håndtere ArrayIndexOutOfBoundsException i Java?
- JAVA-opplæring for nybegynnere: 100+ praktiske Java-videoveiledninger
- JDBC Unntakshåndtering - Hvordan håndtere SQL-unntak
- C # Exception Handling Tutorial med kodeeksempler
- Komplett guide til håndtering av PL SQL-unntak med eksempler
- Unntakshåndtering i C ++
- Python Prøv unntatt - Unntak for Python-håndtering med eksempler