logo

Uitzonderingen op Java

Afhandeling van uitzonderingen in Java is een van de effectieve manieren om runtime-fouten af ​​te handelen, zodat de reguliere stroom van de applicatie behouden kan blijven. Java Exception Handling is een mechanisme voor het afhandelen van runtimefouten zoals ClassNotFoundException, IOException, SQLException, RemoteException, enz.

Wat zijn Java-uitzonderingen?

Op Java: uitzondering is een ongewenste of onverwachte gebeurtenis die optreedt tijdens de uitvoering van een programma, dat wil zeggen tijdens runtime, en die de normale stroom van de programma-instructies verstoort. Uitzonderingen kunnen door het programma worden opgevangen en afgehandeld. Wanneer er binnen een methode een uitzondering optreedt, wordt er een object gemaakt. Dit object wordt het uitzonderingsobject genoemd. Het bevat informatie over de uitzondering, zoals de naam en beschrijving van de uitzondering en de status van het programma toen de uitzondering plaatsvond.



Belangrijkste redenen waarom er een uitzondering optreedt

  • Ongeldige gebruikersinvoer
  • Apparaatfout
  • Verlies van netwerkverbinding
  • Fysieke beperkingen (geheugen buiten schijf)
  • Codefouten
  • Een niet-beschikbaar bestand openen

Fouten vertegenwoordigen onherstelbare omstandigheden, zoals een Java Virtual Machine (JVM) die onvoldoende geheugen heeft, geheugenlekken, stack-overflow-fouten, incompatibiliteit van bibliotheken, oneindige recursie, enz. Fouten vallen meestal buiten de controle van de programmeur en we moeten niet proberen fouten op te lossen.

Verschil tussen fout en uitzondering

Laten we het belangrijkste onderdeel bespreken, namelijk de verschillen tussen fout en uitzondering dat is als volgt:

  • Fout: Een fout duidt op een ernstig probleem dat een redelijke toepassing niet zou moeten proberen op te lossen.
  • Uitzondering: Uitzonderingen geven omstandigheden aan die een redelijke toepassing zou kunnen proberen te ondervangen.

Uitzonderingshiërarchie

Alle uitzonderings- en fouttypen zijn subklassen van de klasse Gooibaar , wat de basisklasse van de hiërarchie is. Eén vestiging wordt geleid door Uitzondering . Deze klasse wordt gebruikt voor uitzonderlijke omstandigheden die gebruikersprogramma's moeten opvangen. NullPointerException is een voorbeeld van een dergelijke uitzondering. Nog een tak, Fout wordt gebruikt door het Java runtime-systeem ( JVM ) om fouten aan te geven die te maken hebben met de runtime-omgeving zelf (JRE). StackOverflowError is een voorbeeld van een dergelijke fout.



reeks structuur in c-taal
Uitzonderingshiërarchie in Java

Hiërarchie van Java-uitzonderingen

Soorten uitzonderingen

Java definieert verschillende soorten uitzonderingen die betrekking hebben op de verschillende klassenbibliotheken. Met Java kunnen gebruikers ook hun eigen uitzonderingen definiëren.

soorten uitzonderingen in Java

Uitzonderingen kunnen op twee manieren worden gecategoriseerd:



  1. Ingebouwde uitzonderingen
    • Uitzondering aangevinkt
    • Niet-aangevinkte uitzondering
  2. Door de gebruiker gedefinieerde uitzonderingen

Laten we de hierboven gedefinieerde uitzondering bespreken, die als volgt is:

1. Ingebouwde uitzonderingen

Ingebouwde uitzonderingen zijn de uitzonderingen die beschikbaar zijn in Java-bibliotheken. Deze uitzonderingen zijn geschikt om bepaalde foutsituaties te verklaren.

  • Gecontroleerde uitzonderingen: Gecontroleerde uitzonderingen worden uitzonderingen tijdens het compileren genoemd, omdat deze uitzonderingen tijdens het compileren door de compiler worden gecontroleerd.
  • Niet-aangevinkte uitzonderingen: De niet-gecontroleerde uitzonderingen zijn precies het tegenovergestelde van de gecontroleerde uitzonderingen. De compiler controleert deze uitzonderingen niet tijdens het compileren. Simpel gezegd: als een programma een ongecontroleerde uitzondering genereert, en zelfs als we deze niet hebben afgehandeld of gedeclareerd, geeft het programma geen compilatiefout.

Opmerking: Zie voor gecontroleerde versus niet-gecontroleerde uitzonderingen Gecontroleerde versus niet-gecontroleerde uitzonderingen

2. Door de gebruiker gedefinieerde uitzonderingen:

Soms zijn de ingebouwde uitzonderingen in Java niet in staat een bepaalde situatie te beschrijven. In dergelijke gevallen kunnen gebruikers ook uitzonderingen maken, die ‘door de gebruiker gedefinieerde uitzonderingen’ worden genoemd.

De voordelen van uitzonderingsafhandeling in Java zijn als volgt:

  1. Voorzieningen om de uitvoering van het programma te voltooien
  2. Gemakkelijke identificatie van programmacode en foutafhandelingscode
  3. Voortplanting van fouten
  4. Betekenisvolle foutrapportage
  5. Fouttypen identificeren

Methoden om de uitzonderingsinformatie af te drukken:

1. printStackTrace()

Deze methode drukt uitzonderingsinformatie af in de notatie Naam van de uitzondering: beschrijving van de uitzondering, stacktrace.

Voorbeeld:

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();> >}> >}> }>

>

>

Uitvoer

java.lang.ArithmeticException: / by zero at GFG.main(File.java:10)>

2. toString()

De methode toString() drukt uitzonderingsinformatie af in de notatie Naam van de uitzondering: beschrijving van de uitzondering.

Voorbeeld:

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());> >}> >}> }>

>

tekenreeksfuncties in Java

>

Uitvoer

java.lang.ArithmeticException: / by zero>

3. getMessage()

De methode getMessage() drukt alleen de beschrijving van de uitzondering af.

Voorbeeld:

Java


java converteert naar string



//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());> >}> >}> }>

>

>

Uitvoer

/ by zero>

Hoe gaat JVM om met een uitzondering?

Standaard afhandeling van uitzonderingen: Wanneer binnen een methode een uitzondering heeft plaatsgevonden, creëert de methode een object dat bekend staat als een uitzonderingsobject en draagt ​​dit over aan het runtimesysteem (JVM). Het uitzonderingsobject bevat de naam en beschrijving van de uitzondering en de huidige status van het programma waarin de uitzondering heeft plaatsgevonden. Het maken van het Exception-object en het verwerken ervan in het runtime-systeem wordt het genereren van een Exception genoemd. Mogelijk bestaat er een lijst met methoden die zijn aangeroepen om bij de methode te komen waar een uitzondering heeft plaatsgevonden. Deze geordende lijst met methoden wordt aangeroepen Bel Stapel . Nu zal de volgende procedure plaatsvinden.

  • Het runtimesysteem doorzoekt de call-stack om de methode te vinden die een codeblok bevat dat de opgetreden uitzondering kan afhandelen. Het blok van de code wordt an genoemd Uitzonderingsbehandelaar .
  • Het runtimesysteem begint te zoeken vanaf de methode waarin de uitzondering heeft plaatsgevonden en gaat door de call-stack in de omgekeerde volgorde waarin de methoden zijn aangeroepen.
  • Als het een geschikte handler vindt, geeft het de opgetreden uitzondering daaraan door. Een geschikte handler betekent dat het type uitzonderingsobject dat wordt gegenereerd overeenkomt met het type uitzonderingsobject dat het kan verwerken.
  • Als het runtimesysteem alle methoden op de call-stack doorzoekt en de juiste handler niet heeft kunnen vinden, draagt ​​het runtimesysteem het uitzonderingsobject over aan de standaard uitzonderingshandler , dat deel uitmaakt van het runtimesysteem. Deze handler drukt de uitzonderingsinformatie af in het volgende formaat en beëindigt het programma abnormaal .
Exception in thread 'xxx' Name of Exception : Description ... ...... .. // Call Stack>

Bekijk het onderstaande diagram om de stroom van de call-stack te begrijpen.

Stroom van klassenstapel voor uitzonderingen in Java

Illustratie:

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());> >}> }>

>

Java splitst de tekenreeks op door een scheidingsteken
>

Uitvoer

programma-uitvoer

Laten we een voorbeeld bekijken dat illustreert hoe een runtimesysteem zoekt naar de juiste code voor het afhandelen van uitzonderingen op de call-stack.

Voorbeeld:

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());> >}> >}> }>

>

>

Uitvoer

/ by zero>

Hoe gaat een programmeur om met een uitzondering?

Aangepaste afhandeling van uitzonderingen: De afhandeling van Java-uitzonderingen wordt beheerd via vijf trefwoorden: poging , vangst , gooien , gooit , En Eindelijk . In het kort, hier is hoe ze werken. Programma-instructies waarvan u denkt dat ze uitzonderingen kunnen opleveren, bevinden zich in een try-blok. Als er binnen het try-blok een uitzondering optreedt, wordt deze gegenereerd. Uw code kan deze uitzondering opvangen (met behulp van het catch-blok) en deze op een rationele manier afhandelen. Door het systeem gegenereerde uitzonderingen worden automatisch gegenereerd door het Java-runtimesysteem. Als u handmatig een uitzondering wilt genereren, gebruikt u het trefwoord throw. Elke uitzondering die uit een methode wordt gegooid, moet als zodanig worden gespecificeerd door een throws-clausule. Elke code die absoluut moet worden uitgevoerd nadat een try-blok is voltooid, wordt in een final-blok geplaatst.

Tip: Men moet er doorheen controlestroom in try catch eindelijk blokkeren voor beter begrip.

Noodzaak van try-catch-clausule (aangepaste afhandeling van uitzonderingen)

Beschouw het onderstaande programma om een ​​beter begrip te krijgen van de try-catch-clausule.

Voorbeeld:

wat is Java-hashmap

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'>);> >}> }>

>

>

Uitvoer

programma-uitvoer

Uitvoer uitleg: In het bovenstaande voorbeeld is een array gedefinieerd met grootte, dat wil zeggen dat u alleen toegang hebt tot elementen van index 0 tot 3. Maar u probeert (per ongeluk) toegang te krijgen tot de elementen op index 4, daarom genereert het een uitzondering. In dit geval beëindigt JVM het programma abnormaal . De verklaring System.out.println (Hallo, ik wil uitvoeren); zal nooit worden uitgevoerd. Om het uit te voeren, moeten we de uitzondering afhandelen met try-catch. Om de normale stroom van het programma voort te zetten, hebben we dus een try-catch-clausule nodig.

Hoe gebruik je de Try-Catch-clausule?

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  }>

Er moeten bepaalde belangrijke punten in gedachten worden gehouden, namelijk:

  • In een methode kan er meer dan één instructie zijn die een uitzondering kan opleveren. Plaats dus al deze uitspraken in hun eigen verklaring poging blokkeren en voorzien in een aparte uitzonderingshandler binnen hun eigen uitzonderingshandler vangst blok voor elk van hen.
  • Als er een uitzondering optreedt binnen de poging blok, wordt die uitzondering afgehandeld door de uitzonderingshandler die eraan is gekoppeld. Om de uitzonderingshandler te koppelen, moeten we a vangst blok erachter. Er kan meer dan één uitzonderingshandler zijn. Elk vangst block is een uitzonderingshandler die de uitzondering afhandelt op het type dat door het argument wordt aangegeven. Het argument ExceptionType declareert het type uitzondering dat het kan verwerken en moet de naam zijn van de klasse die erft van de Gooibaar klas.
  • Voor elk try-blok kunnen er nul of meer catch-blokken zijn, maar maar een laatste blok.
  • Het laatste blok is optioneel. Het wordt altijd uitgevoerd, ongeacht of er een uitzondering is opgetreden in het try-blok of niet. Als er een uitzondering optreedt, wordt deze daarna uitgevoerd probeer blokken te vangen. En als er geen uitzondering optreedt, wordt deze uitgevoerd na de poging blok. Het laatste blok in Java wordt gebruikt om belangrijke codes te plaatsen, zoals opruimcode, bijvoorbeeld het sluiten van het bestand of het sluiten van de verbinding.
  • Als we System.exit in het try-blok schrijven, wordt het blok uiteindelijk niet uitgevoerd.

De samenvatting wordt hieronder via visueel hulpmiddel als volgt weergegeven:

Uitzonderingen op Java

Gerelateerde artikelen:

Verwante Cursussen

Java Programming Foundation – cursus in eigen tempo

Vind de juiste cursus voor u om Java Programming Foundation te leren van experts uit de industrie met jarenlange ervaring. Dit Java Programming Foundation – cursus in eigen tempo behandelt de basisprincipes van de Java-programmeertaal, gegevenstypen, operators en flow control, lussen, strings , en nog veel meer. Nooit meer wachten! Begin nu met het leren van JAVA en word een complete Java-ingenieur!