Undantagshantering i Java är ett av de effektiva sätten att hantera runtime-fel så att programmets regelbundna flöde kan bevaras. Java Exception Handling är en mekanism för att hantera runtime-fel som ClassNotFoundException, IOException, SQLException, RemoteException, etc.
Vad är Java-undantag?
I Java, undantag är en oönskad eller oväntad händelse, som inträffar under körningen av ett program, d.v.s. vid körning, som stör det normala flödet av programmets instruktioner. Undantag kan fångas upp och hanteras av programmet. När ett undantag inträffar inom en metod skapar det ett objekt. Detta objekt kallas undantagsobjektet. Den innehåller information om undantaget, såsom namn och beskrivning av undantaget och programmets tillstånd när undantaget inträffade.
Viktiga skäl till att ett undantag uppstår
- Ogiltig användarinmatning
- Enhetsfel
- Förlust av nätverksanslutning
- Fysiska begränsningar (minne utanför disken)
- Kodfel
- Öppnar en otillgänglig fil
Fel representerar oåterkalleliga tillstånd som Java Virtual Machine (JVM) som tar slut på minne, minnesläckor, stack overflow-fel, biblioteksinkompatibilitet, oändlig rekursion, etc. Fel ligger vanligtvis utanför programmerarens kontroll, och vi bör inte försöka hantera fel.
Skillnaden mellan fel och undantag
Låt oss diskutera den viktigaste delen som är skillnader mellan fel och undantag det är som följer:
- Fel: Ett fel indikerar ett allvarligt problem som ett rimligt program inte bör försöka fånga upp.
- Undantag: Undantag indikerar förhållanden som en rimlig applikation kan försöka fånga.
Undantagshierarki
Alla undantags- och feltyper är underklasser till klassen Kastbar , som är basklassen för hierarkin. En gren leds av Undantag . Denna klass används för exceptionella förhållanden som användarprogram bör fånga. NullPointerException är ett exempel på ett sådant undantag. En annan gren, Fel används av Java runtime system( JVM ) för att indikera fel som har att göra med själva körtidsmiljön (JRE). StackOverflowError är ett exempel på ett sådant fel.
java sträng till heltalskonvertering
Java undantagshierarki
Typer av undantag
Java definierar flera typer av undantag som relaterar till dess olika klassbibliotek. Java tillåter också användare att definiera sina egna undantag.
Undantag kan kategoriseras på två sätt:
- Inbyggda undantag
- Markerat undantag
- Omarkerat undantag
- Användardefinierade undantag
Låt oss diskutera det ovan definierade undantaget som är följande:
1. Inbyggda undantag
Inbyggda undantag är de undantag som är tillgängliga i Java-bibliotek. Dessa undantag är lämpliga för att förklara vissa felsituationer.
- Markerade undantag: Markerade undantag kallas undantag vid kompilering eftersom dessa undantag kontrolleras vid kompilering av kompilatorn.
- Omarkerade undantag: De omarkerade undantagen är precis motsatta de markerade undantagen. Kompilatorn kontrollerar inte dessa undantag vid kompilering. Med enkla ord, om ett program ger ett okontrollerat undantag, och även om vi inte hanterade eller deklarerade det, skulle programmet inte ge ett kompileringsfel.
Notera: För markerat eller omarkerat undantag, se Markerade vs omarkerade undantag
2. Användardefinierade undantag:
Ibland kan de inbyggda undantagen i Java inte beskriva en viss situation. I sådana fall kan användare också skapa undantag, som kallas 'användardefinierade undantag'.
De fördelar med undantagshantering i Java är följande:
- Avsättning för att slutföra programexekvering
- Enkel identifiering av programkod och felhanteringskod
- Spridning av fel
- Meningsfull felrapportering
- Identifiera feltyper
Metoder för att skriva ut undantagsinformationen:
1. printStackTrace()
Denna metod skriver ut undantagsinformation i formatet Namn på undantaget: beskrivning av undantaget, stackspårning.
Exempel:
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() skriver ut undantagsinformation i formatet Namn på undantaget: beskrivning av undantaget.
Exempel:
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());> >}> >}> }> |
>
java-operatör
>
Produktion
java.lang.ArithmeticException: / by zero>
3. getMessage()
Metoden getMessage() skriver endast ut beskrivningen av undantaget.
Exempel:
Java
array vs arraylist
//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>
Hur hanterar JVM ett undantag?
Standard undantagshantering: Närhelst inom en metod, om ett undantag har inträffat, skapar metoden ett objekt som kallas ett undantagsobjekt och lämnar det till runtime-systemet (JVM). Undantagsobjektet innehåller namnet och beskrivningen av undantaget och det aktuella tillståndet för programmet där undantaget har inträffat. Att skapa undantagsobjektet och hantera det i körtidssystemet kallas att kasta ett undantag. Det kan finnas en lista över de metoder som hade anropats för att komma till metoden där ett undantag inträffade. Denna ordnade lista över metoder kallas Ring Stack . Nu kommer följande procedur att ske.
- Runtime-systemet söker igenom anropsstacken för att hitta metoden som innehåller ett kodblock som kan hantera det inträffade undantaget. Kodens block kallas an Undantagshanterare .
- Körtidssystemet börjar söka från metoden där undantaget inträffade och fortsätter genom anropsstacken i omvänd ordning som metoderna anropades.
- Om den hittar en lämplig hanterare skickar den det inträffade undantaget till den. En lämplig hanterare betyder att typen av undantagsobjekt som kastas matchar typen av undantagsobjekt som det kan hantera.
- Om runtime-systemet söker igenom alla metoder i anropsstacken och inte kunde ha hittat rätt hanterare, överlämnar runtime-systemet undantagsobjektet till standard undantagshanterare , som är en del av körtidssystemet. Denna hanterare skriver ut undantagsinformationen i följande format och avslutar programmet onormalt .
Exception in thread 'xxx' Name of Exception : Description ... ...... .. // Call Stack>
Titta på diagrammet nedan för att förstå flödet av samtalsstacken.
Illustration:
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());> >}> }> |
>
array.sort i java
>
Produktion
Låt oss se ett exempel som illustrerar hur ett körtidssystem söker efter lämplig undantagshanteringskod på anropsstacken.
Exempel:
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>
Hur hanterar programmerare ett undantag?
Anpassad undantagshantering: Java-undantagshantering hanteras via fem nyckelord: Prova , fånga , kasta , kastar , och till sist . Kortfattat, här är hur de fungerar. Programsatser som du tror kan ge undantag finns i ett försöksblock. Om ett undantag inträffar inom försöksblocket kastas det. Din kod kan fånga detta undantag (med catch-block) och hantera det på något rationellt sätt. Systemgenererade undantag kastas automatiskt av Java runtime-systemet. För att manuellt kasta ett undantag, använd nyckelordet throw. Alla undantag som kastas ut från en metod måste specificeras som sådant av en throws-sats. Varje kod som absolut måste exekveras efter att ett försöksblock har slutförts läggs i ett finalblock.
Dricks: Man måste gå igenom kontrollera flödet i försök fånga äntligen blockera för bättre förståelse.
Behov av try-catch-klausul (anpassad undantagshantering)
Tänk på programmet nedan för att få en bättre förståelse av try-catch-klausulen.
Exempel:
hur man får aktuellt datum i java
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
Utgångsförklaring: I exemplet ovan definieras en array med storlek, det vill säga du kan bara komma åt element från index 0 till 3. Men du försöker komma åt elementen vid index 4 (av misstag) det är därför det ger ett undantag. I det här fallet avslutar JVM programmet onormalt . Uttalandet System.out.println(Hej, jag vill köra); kommer aldrig att genomföras. För att exekvera det måste vi hantera undantaget med try-catch. För att fortsätta programmets normala flöde behöver vi därför en try-catch-klausul.
Hur använder 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 }> Vissa nyckelpunkter måste komma ihåg som är följande:
- I en metod kan det finnas mer än ett påstående som kan skapa ett undantag, så lägg alla dessa påståenden inom sina egna Prova blockera och tillhandahålla en separat undantagshanterare inom sin egen fånga block för var och en av dem.
- Om ett undantag inträffar inom Prova block, hanteras det undantaget av undantagshanteraren som är associerad med det. För att associera undantagshanteraren måste vi sätta en fånga blockera efter det. Det kan finnas mer än en undantagshanterare. Varje fånga block är en undantagshanterare som hanterar undantaget från den typ som anges av dess argument. Argumentet ExceptionType deklarerar vilken typ av undantag det kan hantera och måste vara namnet på klassen som ärver från Kastbar klass.
- För varje försöksblock kan det finnas noll eller fler fångstblock, men bara en sista blocket.
- Det sista blocket är valfritt. Det exekveras alltid oavsett om ett undantag inträffade i försöksblocket eller inte. Om ett undantag inträffar kommer det att exekveras efter försök fånga block. Och om ett undantag inte inträffar, kommer det att exekveras efter Prova blockera. Finalblocket i Java används för att lägga in viktiga koder som rensningskod, t.ex. stänga filen eller stänga anslutningen.
- Om vi skriver System.exit i försöksblocket kommer blocket slutligen inte att exekveras.
Sammanfattningen är avbildad via visuell hjälp nedan enligt följande:
Relaterade artiklar:
- Typer av undantag i Java
- Markerade vs omarkerade undantag
- Kastkast i Java
Relaterade kurser
Java Programming Foundation – Kurs i självtempo
Hitta rätt kurs för att börja lära dig Java Programming Foundation från branschexperter som har många års erfarenhet. Detta Java Programming Foundation – Kurs i självtempo täcker grunderna i Java programmeringsspråk, datatyper, operatorer och flödeskontroll, loopar, strängar , och mycket mer. Ingen mer väntan! Börja lära dig JAVA nu och bli en komplett Java-ingenjör!