Undtagelseshåndtering i Java er et af de effektive midler til at håndtere runtime fejl, så det regelmæssige flow af applikationen kan bevares. Java Exception Handling er en mekanisme til at håndtere runtime fejl såsom ClassNotFoundException, IOException, SQLException, RemoteException osv.
Hvad er Java-undtagelser?
I Java, Undtagelse er en uønsket eller uventet hændelse, som opstår under afviklingen af et program, dvs. ved kørsel, som forstyrrer det normale flow af programmets instruktioner. Undtagelser kan fanges og håndteres af programmet. Når der opstår en undtagelse inden for en metode, opretter den et objekt. Dette objekt kaldes undtagelsesobjektet. Den indeholder oplysninger om undtagelsen, såsom navn og beskrivelse af undtagelsen og programmets tilstand, da undtagelsen indtraf.
Vigtigste årsager til, at en undtagelse opstår
- Ugyldig brugerinput
- Enhedsfejl
- Tab af netværksforbindelse
- Fysiske begrænsninger (hukommelse uden for disk)
- Kode fejl
- Åbner en utilgængelig fil
Fejl repræsentere uoprettelige tilstande såsom Java virtual machine (JVM), der løber tør for hukommelse, hukommelseslækager, stak overløbsfejl, biblioteksinkompatibilitet, uendelig rekursion osv. Fejl er normalt uden for programmørens kontrol, og vi bør ikke forsøge at håndtere fejl.
Forskellen mellem fejl og undtagelse
Lad os diskutere den vigtigste del, som er forskelle mellem fejl og undtagelse det er som følger:
- Fejl: En fejl angiver et alvorligt problem, som en fornuftig applikation ikke bør forsøge at fange.
- Undtagelse: Undtagelse angiver forhold, som en rimelig applikation kan forsøge at fange.
Undtagelseshierarki
Alle undtagelses- og fejltyper er underklasser af klassen Kan kastes , som er basisklassen i hierarkiet. En afdeling ledes af Undtagelse . Denne klasse bruges til ekstraordinære forhold, som brugerprogrammer bør fange. NullPointerException er et eksempel på en sådan undtagelse. En anden gren, Fejl bruges af Java run-time system( JVM ) for at indikere fejl, der har at gøre med selve runtime-miljøet (JRE). StackOverflowError er et eksempel på en sådan fejl.
Java-undtagelseshierarki
Typer af undtagelser
Java definerer flere typer undtagelser, der vedrører dets forskellige klassebiblioteker. Java giver også brugerne mulighed for at definere deres egne undtagelser.
Undtagelser kan kategoriseres på to måder:
- Indbyggede undtagelser
- Afkrydset undtagelse
- Ikke markeret undtagelse
- Brugerdefinerede undtagelser
Lad os diskutere den ovenfor definerede undtagelse, der er som følger:
1. Indbyggede undtagelser
Indbyggede undtagelser er de undtagelser, der er tilgængelige i Java-biblioteker. Disse undtagelser er velegnede til at forklare visse fejlsituationer.
- Markerede undtagelser: Afkrydsede undtagelser kaldes undtagelser på kompileringstidspunktet, fordi disse undtagelser kontrolleres på kompileringstidspunktet af compileren.
- Ikke-markerede undtagelser: De umarkerede undtagelser er lige modsatte af de afkrydsede undtagelser. Compileren vil ikke kontrollere disse undtagelser på kompileringstidspunktet. Med enkle ord, hvis et program kaster en ukontrolleret undtagelse, og selvom vi ikke håndterede eller erklærede den, ville programmet ikke give en kompileringsfejl.
Bemærk: For markeret vs umarkeret undtagelse, se Markerede vs umarkerede undtagelser
java type konvertering og støbning
2. Brugerdefinerede undtagelser:
Nogle gange er de indbyggede undtagelser i Java ikke i stand til at beskrive en bestemt situation. I sådanne tilfælde kan brugere også oprette undtagelser, som kaldes 'brugerdefinerede undtagelser'.
Det fordele ved undtagelseshåndtering i Java er som følgende:
- Hensættelse til at fuldføre programudførelse
- Nem identifikation af programkode og fejlhåndteringskode
- Udbredelse af fejl
- Meningsfuld fejlrapportering
- Identifikation af fejltyper
Metoder til at udskrive undtagelsesoplysningerne:
1. printStackTrace()
Denne metode udskriver undtagelsesoplysninger i formatet Navn på undtagelsen: beskrivelse af undtagelsen, staksporing.
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();> >}> >}> }> |
>
>
Produktion
java.lang.ArithmeticException: / by zero at GFG.main(File.java:10)>
2. toString()
Metoden toString() udskriver undtagelsesoplysninger i formatet Navn på undtagelsen: beskrivelse af undtagelsen.
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());> >}> >}> }> |
>
>
Produktion
java.lang.ArithmeticException: / by zero>
3. getMessage()
GetMessage()-metoden udskriver kun beskrivelsen af undtagelsen.
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());> >}> >}> }> |
>
>
Produktion
/ by zero>
Hvordan håndterer JVM en undtagelse?
Standard undtagelseshåndtering: Når som helst inde i en metode, hvis der er opstået en undtagelse, opretter metoden et objekt kendt som et undtagelsesobjekt og videregiver det til run-time-systemet (JVM). Undtagelsesobjektet indeholder navn og beskrivelse af undtagelsen og den aktuelle tilstand for det program, hvor undtagelsen er opstået. Oprettelse af undtagelsesobjektet og håndtering af det i runtime-systemet kaldes at kaste en undtagelse. Der kan være en liste over de metoder, der var blevet kaldt for at komme til den metode, hvor der opstod en undtagelse. Denne ordnede liste over metoder kaldes Ring til stak . Nu vil følgende procedure ske.
- Runtime-systemet søger i opkaldsstakken for at finde den metode, der indeholder en kodeblok, der kan håndtere den opståede undtagelse. Blokken af koden kaldes en Undtagelsesbehandler .
- Runtime-systemet begynder at søge fra den metode, hvor undtagelsen opstod, og fortsætter gennem opkaldsstakken i omvendt rækkefølge, som metoderne blev kaldt.
- Hvis den finder en passende behandler, videregiver den den opståede undtagelse til den. En passende handler betyder, at typen af det kastede undtagelsesobjekt matcher den type undtagelsesobjekt, det kan håndtere.
- Hvis runtime-systemet søger i alle metoderne på opkaldsstakken og ikke kunne have fundet den passende handler, så overdrager run-time-systemet undtagelsesobjektet til standard undtagelsesbehandler , som er en del af runtime-systemet. Denne behandler udskriver undtagelsesoplysningerne i følgende format og afslutter programmet unormalt .
Exception in thread 'xxx' Name of Exception : Description ... ...... .. // Call Stack>
Se på nedenstående diagram for at forstå flowet af opkaldsstakken.
Illustration:
Java
minimax algoritme
// 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());> >}> }> |
>
>
Produktion
Lad os se et eksempel, der illustrerer, hvordan et runtime-system søger efter passende undtagelseshåndteringskode på opkaldsstakken.
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());> >}> >}> }> |
>
>Produktion
/ by zero>
Hvordan håndterer programmør en undtagelse?
Tilpasset undtagelseshåndtering: Håndtering af Java-undtagelser administreres via fem nøgleord: prøve , fangst , kaste , kaster , og endelig . Kort fortalt, her er hvordan de fungerer. Programsætninger, som du mener kan give undtagelser, er indeholdt i en prøveblok. Hvis der opstår en undtagelse inden for prøveblokken, kastes den. Din kode kan fange denne undtagelse (ved hjælp af catch-blok) og håndtere den på en rationel måde. Systemgenererede undtagelser kastes automatisk af Java-run-time-systemet. For manuelt at kaste en undtagelse, brug nøgleordet throw. Enhver undtagelse, der er smidt ud af en metode, skal specificeres som sådan af en throws-klausul. Enhver kode, der absolut skal udføres, efter at en prøveblok er fuldført, sættes i en endelig blok.
Tip: Man skal igennem kontrol flow i prøv catch endelig blok for bedre forståelse.
Behov for try-catch-klausul (tilpasset undtagelseshåndtering)
Overvej nedenstående program for at få en bedre forståelse af try-catch-klausulen.
quicksort
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'>);> >}> }> |
>
>
Produktion
Output forklaring: I ovenstående eksempel er et array defineret med størrelse, dvs. du kan kun få adgang til elementer fra indeks 0 til 3. Men du forsøger at få adgang til elementerne ved indeks 4 (ved en fejltagelse), det er derfor, det kaster en undtagelse. I dette tilfælde afslutter JVM programmet unormalt . Udsagnet System.out.println(Hej, jeg vil udføre); vil aldrig udføre. For at udføre det, skal vi håndtere undtagelsen ved hjælp af try-catch. For at fortsætte programmets normale flow har vi derfor brug for en try-catch-klausul.
Hvordan bruger man 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 }> Visse nøglepunkter skal huskes, som er som følger:
- I en metode kan der være mere end et udsagn, der kan give en undtagelse, så sæt alle disse udsagn inden for deres egne prøve blokere og give en separat undtagelsesbehandler inden for deres egen fangst blok for hver af dem.
- Hvis der opstår en undtagelse inden for prøve blok, håndteres denne undtagelse af den undtagelsesbehandler, der er knyttet til den. For at tilknytte undtagelsesbehandleren skal vi sætte en fangst blokere efter det. Der kan være mere end én undtagelseshandler. Hver fangst blok er en undtagelsesbehandler, der håndterer undtagelsen til typen angivet af dens argument. Argumentet ExceptionType erklærer den type undtagelse, den kan håndtere, og skal være navnet på den klasse, der arver fra Kan kastes klasse.
- For hver forsøgsblok kan der være nul eller flere catch-blokke, men kun en sidste blok.
- Den endelige blok er valgfri. Det bliver altid eksekveret, uanset om der opstod en undtagelse i prøveblokken eller ej. Hvis der opstår en undtagelse, vil den blive udført efter prøv at fange blokke. Og hvis en undtagelse ikke forekommer, vil den blive udført efter prøve blok. Den endelige blok i Java bruges til at sætte vigtige koder, såsom oprydningskode, f.eks. lukning af filen eller lukning af forbindelsen.
- Hvis vi skriver System.exit i try-blokken, vil blokeringen endelig ikke blive udført.
Resuméet er afbildet via visuelt hjælpemiddel nedenfor som følger:
Relaterede artikler:
- Typer af undtagelser i Java
- Markerede vs umarkerede undtagelser
- Kast-kast i Java
Relaterede kurser
Java Programming Foundation – Kursus i selv-tempo
Find det rigtige kursus for dig, så du kan begynde at lære Java Programming Foundation fra brancheeksperter med mange års erfaring. Det her Java Programming Foundation – Kursus i eget tempo dækker det grundlæggende i Java programmeringssprog, datatyper, operatører og flowkontrol, loops, strenge , og meget mere. Ikke længere ventetid! Begynd at lære JAVA nu og bliv en komplet Java-ingeniør!