Avvikshåndtering i Java er en av de effektive måtene å håndtere kjøretidsfeil slik at den vanlige flyten av applikasjonen kan bevares. Java Exception Handling er en mekanisme for å håndtere kjøretidsfeil som ClassNotFoundException, IOException, SQLException, RemoteException, etc.
Hva er Java-unntak?
I Java, unntak er en uønsket eller uventet hendelse, som oppstår under kjøringen av et program, dvs. under kjøretid, som forstyrrer den normale flyten av programmets instruksjoner. Unntak kan fanges opp og håndteres av programmet. Når et unntak oppstår innenfor en metode, oppretter det et objekt. Dette objektet kalles unntaksobjektet. Den inneholder informasjon om unntaket, for eksempel navn og beskrivelse av unntaket og tilstanden til programmet da unntaket skjedde.
Hovedårsaker til at et unntak oppstår
- Ugyldig brukerinndata
- Enhetsfeil
- Tap av nettverksforbindelse
- Fysiske begrensninger (minne utenfor disk)
- Kodefeil
- Åpner en utilgjengelig fil
Feil representerer uopprettelige forhold som Java Virtual Machine (JVM) som går tom for minne, minnelekkasjer, stack overflow-feil, biblioteksinkompatibilitet, uendelig rekursjon osv. Feil er vanligvis utenfor programmererens kontroll, og vi bør ikke prøve å håndtere feil.
Forskjellen mellom feil og unntak
La oss diskutere den viktigste delen som er forskjeller mellom feil og unntak det er som følger:
- Feil: En feil indikerer et alvorlig problem som et rimelig program ikke bør prøve å fange opp.
- Unntak: Unntak indikerer forhold som en rimelig applikasjon kan prøve å fange opp.
Unntakshierarki
Alle unntaks- og feiltyper er underklasser av klassen Kastbar , som er basisklassen til hierarkiet. En gren ledes av Unntak . Denne klassen brukes for eksepsjonelle forhold som brukerprogrammer bør fange opp. NullPointerException er et eksempel på et slikt unntak. En annen gren, Feil brukes av Java run-time system( JVM ) for å indikere feil som har å gjøre med selve kjøretidsmiljøet (JRE). StackOverflowError er et eksempel på en slik feil.
Java-unntakshierarki
Typer unntak
Java definerer flere typer unntak som er relatert til de forskjellige klassebibliotekene. Java lar også brukere definere sine egne unntak.
Unntak kan kategoriseres på to måter:
- Innebygde unntak
- Merket av for unntak
- Uavmerket unntak
- Brukerdefinerte unntak
La oss diskutere det ovenfor definerte unntaket som er som følger:
1. Innebygde unntak
Innebygde unntak er unntakene som er tilgjengelige i Java-biblioteker. Disse unntakene er egnet til å forklare visse feilsituasjoner.
- Avmerkede unntak: Kontrollerte unntak kalles unntak fra kompileringstid fordi disse unntakene kontrolleres ved kompilering av kompilatoren.
- Unntak som ikke er avmerket: De ukontrollerte unntakene er motsatte av de avmerkede unntakene. Kompilatoren vil ikke sjekke disse unntakene på kompileringstidspunktet. Med enkle ord, hvis et program kaster et ukontrollert unntak, og selv om vi ikke håndterte eller erklærte det, ville ikke programmet gi en kompileringsfeil.
Merk: For avmerket kontra uavmerket unntak, se Avmerket vs ukontrollerte unntak
java konverter heltall til streng
2. Brukerdefinerte unntak:
Noen ganger er de innebygde unntakene i Java ikke i stand til å beskrive en bestemt situasjon. I slike tilfeller kan brukere også opprette unntak, som kalles 'brukerdefinerte unntak'.
De fordeler med unntakshåndtering i Java er som følger:
- Avsetning for å fullføre programutførelse
- Enkel identifisering av programkode og feilhåndteringskode
- Utbredelse av feil
- Meningsfull feilrapportering
- Identifisere feiltyper
Metoder for å skrive ut unntaksinformasjonen:
1. printStackTrace()
Denne metoden skriver ut unntaksinformasjon i formatet Navn på unntaket: beskrivelse av unntaket, stabelsporing.
Eksempel:
Java
//program to print the exception information using printStackTrace() method> > import> java.io.*;> > class> GFG {> >public> static> void> main (String[] args) {> >int> a=>5>;> >int> b=>0>;> >try>{> >System.out.println(a/b);> >}> >catch>(ArithmeticException e){> >e.printStackTrace();> >}> >}> }> |
>
>
Produksjon
java.lang.ArithmeticException: / by zero at GFG.main(File.java:10)>
2. toString()
Metoden toString() skriver ut unntaksinformasjon i formatet Navn på unntaket: beskrivelse av unntaket.
Eksempel:
Java
//program to print the exception information using toString() method> > import> java.io.*;> > class> GFG1 {> >public> static> void> main (String[] args) {> >int> a=>5>;> >int> b=>0>;> >try>{> >System.out.println(a/b);> >}> >catch>(ArithmeticException e){> >System.out.println(e.toString());> >}> >}> }> |
>
>
Produksjon
java.lang.ArithmeticException: / by zero>
3. getMessage()
GetMessage()-metoden skriver bare ut beskrivelsen av unntaket.
Eksempel:
Java
//program to print the exception information using getMessage() method> > import> java.io.*;> > class> GFG1 {> >public> static> void> main (String[] args) {> >int> a=>5>;> >int> b=>0>;> >try>{> >System.out.println(a/b);> >}> >catch>(ArithmeticException e){> >System.out.println(e.getMessage());> >}> >}> }> |
>
>
Produksjon
/ by zero>
Hvordan håndterer JVM et unntak?
Standard unntakshåndtering: Når det er inne i en metode, hvis et unntak har skjedd, oppretter metoden et objekt kjent som et unntaksobjekt og overleverer det til kjøretidssystemet (JVM). Unntaksobjektet inneholder navn og beskrivelse av unntaket og gjeldende tilstand for programmet der unntaket har skjedd. Å lage unntaksobjektet og håndtere det i kjøretidssystemet kalles å kaste et unntak. Det kan være en liste over metodene som ble kalt for å komme til metoden der et unntak skjedde. Denne ordnede listen over metoder kalles Ring Stack . Nå vil følgende prosedyre skje.
- Kjøretidssystemet søker i anropsstakken for å finne metoden som inneholder en kodeblokk som kan håndtere det oppståtte unntaket. Blokken av koden kalles en Unntaksbehandler .
- Kjøretidssystemet begynner å søke fra metoden der unntaket skjedde og fortsetter gjennom anropsstakken i omvendt rekkefølge metodene ble kalt.
- Hvis den finner en passende behandler, sender den det oppståtte unntaket til den. En passende behandler betyr at typen unntaksobjekt som kastes samsvarer med typen unntaksobjekt den kan håndtere.
- Hvis kjøretidssystemet søker etter alle metodene på anropsstakken og ikke kunne ha funnet den riktige behandleren, overlater kjøretidssystemet unntaksobjektet til standard unntaksbehandler , som er en del av kjøretidssystemet. Denne behandleren skriver ut unntaksinformasjonen i følgende format og avslutter programmet unormalt .
Exception in thread 'xxx' Name of Exception : Description ... ...... .. // Call Stack>
Se på diagrammet nedenfor for å forstå flyten til anropsstakken.
Illustrasjon:
Java
snu strengen i java
// Java Program to Demonstrate How Exception Is Thrown> > // Class> // ThrowsExecp> class> GFG {> > >// Main driver method> >public> static> void> main(String args[])> >{> >// Taking an empty string> >String str =>null>;> >// Getting length of a string> >System.out.println(str.length());> >}> }> |
>
>
Produksjon
La oss se et eksempel som illustrerer hvordan et kjøretidssystem søker etter passende unntakshåndteringskode på anropsstakken.
Eksempel:
Java
// Java Program to Demonstrate Exception is Thrown> // How the runTime System Searches Call-Stack> // to Find Appropriate Exception Handler> > // Class> // ExceptionThrown> class> GFG {> > >// Method 1> >// It throws the Exception(ArithmeticException).> >// Appropriate Exception handler is not found> >// within this method.> >static> int> divideByZero(>int> a,>int> b)> >{> > >// this statement will cause ArithmeticException> >// (/by zero)> >int> i = a / b;> > >return> i;> >}> > >// The runTime System searches the appropriate> >// Exception handler in method also but couldn't have> >// found. So looking forward on the call stack> >static> int> computeDivision(>int> a,>int> b)> >{> > >int> res =>0>;> > >// Try block to check for exceptions> >try> {> > >res = divideByZero(a, b);> >}> > >// Catch block to handle NumberFormatException> >// exception Doesn't matches with> >// ArithmeticException> >catch> (NumberFormatException ex) {> >// Display message when exception occurs> >System.out.println(> >'NumberFormatException is occurred'>);> >}> >return> res;> >}> > >// Method 2> >// Found appropriate Exception handler.> >// i.e. matching catch block.> >public> static> void> main(String args[])> >{> > >int> a =>1>;> >int> b =>0>;> > >// Try block to check for exceptions> >try> {> >int> i = computeDivision(a, b);> >}> > >// Catch block to handle ArithmeticException> >// exceptions> >catch> (ArithmeticException ex) {> > >// getMessage() will print description> >// of exception(here / by zero)> >System.out.println(ex.getMessage());> >}> >}> }> |
>
>Produksjon
/ by zero>
Hvordan håndterer programmerer et unntak?
Tilpasset unntakshåndtering: Java-unntakshåndtering administreres via fem nøkkelord: prøve , å fange , kaste , kaster , og endelig . Kort fortalt, her er hvordan de fungerer. Programsetninger som du tror kan gi unntak, finnes i en prøveblokk. Hvis et unntak oppstår innenfor prøveblokken, blir det kastet. Koden din kan fange dette unntaket (ved hjelp av catch-blokk) og håndtere det på en rasjonell måte. Systemgenererte unntak blir automatisk kastet av Java-kjøretidssystemet. For å kaste et unntak manuelt, bruk nøkkelordet throw. Ethvert unntak som kastes ut av en metode må spesifiseres som sådan av en kast-klausul. Enhver kode som absolutt må utføres etter at en prøveblokk er fullført, legges i en endelig blokk.
Tips: Man må gjennom kontrollflyt i try catch endelig blokk for bedre forståelse.
Behov for try-catch-klausul (tilpasset unntakshåndtering)
Vurder programmet nedenfor for å få en bedre forståelse av try-catch-klausulen.
liste i java
Eksempel:
Java
// Java Program to Demonstrate> // Need of try-catch Clause> > // Class> class> GFG {> > >// Main driver method> >public> static> void> main(String[] args)> >{> >// Taking an array of size 4> >int>[] arr =>new> int>[>4>];> > >// Now this statement will cause an exception> >int> i = arr[>4>];> > >// This statement will never execute> >// as above we caught with an exception> >System.out.println(>'Hi, I want to execute'>);> >}> }> |
>
>
Produksjon
Utgangsforklaring: I eksemplet ovenfor er en matrise definert med størrelse, dvs. du kan bare få tilgang til elementer fra indeks 0 til 3. Men du prøver å få tilgang til elementene på indeks 4 (ved en feiltakelse), det er derfor det gir et unntak. I dette tilfellet avslutter JVM programmet unormalt . Utsagnet System.out.println(Hei, jeg vil kjøre); vil aldri gjennomføre. For å utføre det, må vi håndtere unntaket ved å bruke try-catch. Derfor trenger vi en try-catch-klausul for å fortsette den normale flyten av programmet.
Hvordan bruke try-catch-klausulen?
try { // block of code to monitor for errors // the code you think can raise an exception } catch (ExceptionType1 exOb) { // exception handler for ExceptionType1 } catch (ExceptionType2 exOb) { // exception handler for ExceptionType2 } // optional finally { // block of code to be executed after try block ends }> Enkelte nøkkelpunkter må huskes som er som følger:
- I en metode kan det være mer enn én setning som kan gi et unntak, så legg alle disse setningene innenfor sine egne prøve blokkere og gi en separat unntaksbehandler i sin egen å fange blokk for hver av dem.
- Hvis det oppstår et unntak innenfor prøve blokk, håndteres dette unntaket av unntaksbehandleren som er knyttet til det. For å tilknytte unntaksbehandleren må vi sette en å fange blokker etter den. Det kan være mer enn én unntaksbehandler. Hver å fange block er en unntaksbehandler som håndterer unntaket til typen som er angitt av argumentet. Argumentet ExceptionType erklærer typen unntak den kan håndtere og må være navnet på klassen som arver fra Kastbar klasse.
- For hver forsøksblokk kan det være null eller flere fangstblokker, men bare en siste blokk.
- Den endelige blokken er valgfri. Den blir alltid utført uansett om et unntak skjedde i prøveblokken eller ikke. Hvis det oppstår et unntak, vil det bli utført etterpå prøve å fange blokker. Og hvis et unntak ikke forekommer, vil det bli utført etter prøve blokkere. Den endelige blokken i Java brukes til å sette viktige koder som oppryddingskode, for eksempel å lukke filen eller lukke forbindelsen.
- Hvis vi skriver System.exit i try-blokken, vil blokken til slutt ikke bli utført.
Sammendraget er avbildet via visuelle hjelpemidler nedenfor som følger:
Relaterte artikler:
- Typer unntak i Java
- Avmerket vs ukontrollerte unntak
- Kast-kast i Java
Relaterte kurs
Java Programming Foundation – Kurs i eget tempo
Finn det riktige kurset for å begynne å lære Java Programming Foundation fra bransjeekspertene som har mange års erfaring. Dette Java Programming Foundation – Kurs i eget tempo dekker det grunnleggende i Java programmeringsspråk, datatyper, operatører og flytkontroll, looper, strenger , og mye mer. Ikke mer venting! Begynn å lære JAVA nå og bli en komplett Java-ingeniør!