Java-uitzonderingen op de juiste manier verwerken

Als een programmeur newbie Leren programmeren zonder al de stress Leren programmeren zonder alle stress Misschien heb je besloten om te blijven programmeren, of het nu voor een carrière is of gewoon als een hobby. Super goed! Maar misschien begin je je overweldigd te voelen. Niet zo goed. Hier is hulp om uw reis te vergemakkelijken. Lees meer, het concept van afhandeling van uitzonderingen kan lastig zijn om je hoofd rond te wikkelen. Niet dat het concept zelf moeilijk is, maar door de terminologie kan het geavanceerder lijken dan het is. En het is zo'n krachtige functie dat het vatbaar is voor misbruik en misbruik.

In dit artikel leert u welke uitzonderingen zijn, waarom ze belangrijk zijn, hoe u ze kunt gebruiken en veelvoorkomende fouten die u moet vermijden. Meest moderne talen 6 Eenvoudigste programmeertalen om te leren voor beginners 6 Eenvoudigste programmeertalen om te leren voor beginners Leren programmeren gaat net zo goed over het vinden van de juiste taal als over het leerproces. Hier zijn de top zes van gemakkelijkste programmeertalen voor beginners. Read More heeft een vorm van uitzonderingsafhandeling, dus als je ooit verder gaat vanuit Java 7 Handige trucs voor het beheersen van een nieuwe programmeertaal 7 Nuttige trucs voor het beheersen van een nieuwe programmeertaal Het is goed om overweldigd te zijn wanneer je leert programmeren. Je zult dingen waarschijnlijk zo snel vergeten als je ze leert. Deze tips kunnen u helpen om al die nieuwe informatie beter te bewaren. Lees Meer, u kunt de meeste van deze tips met u meenemen.

Java-uitzonderingen begrijpen

In Java, een uitzondering is een object dat iets abnormaals aangeeft (of “buitengewoon”) opgetreden tijdens de uitvoering van uw toepassing. Dergelijke uitzonderingen zijn gegooid, wat in feite betekent dat een uitzonderingsobject is gemaakt (vergelijkbaar met hoe fouten zijn “verheven”).

Het mooie is dat je het kunt vangst gegooide uitzonderingen, waarmee u de abnormale situatie kunt aanpakken en uw toepassing kunt laten doorgaan alsof er niets fout is gegaan. Bijvoorbeeld, terwijl een lege aanwijzer in C uw toepassing kan laten crashen, laat Java u gooien en vangen NullPointerExceptions voordat een nulvariabele kans maakt om een ​​crash te veroorzaken.

Denk eraan, een uitzondering is slechts een object, maar met één belangrijk kenmerk: het moet worden uitgebreid van het Uitzondering klasse of een subklasse van Uitzondering. Hoewel Java allerlei ingebouwde uitzonderingen heeft, kunt u ook uw eigen maken als u dat wilt. Enkele van de meest voorkomende Java-uitzonderingen zijn onder meer:

• NullPointerException
• NumberFormatException
• IllegalArgumentException
• RuntimeException
• IllegalStateException

Dus wat gebeurt er als je een uitzondering gooit?

Ten eerste kijkt Java binnen de directe methode om te zien of er code is die omgaat met de soort uitzondering die je gooide. Als een handler niet bestaat, wordt gekeken naar de methode die de huidige methode heeft aangeroepen om te zien of er een handle bestaat. Zo niet, dan wordt gekeken naar de methode die heeft gebeld dat methode, en vervolgens de volgende methode, enz. Als de uitzondering niet wordt opgevangen, drukt de toepassing een stacktracé af en crasht vervolgens. (Eigenlijk is het genuanceerder dan gewoon crashen, maar dat is een geavanceerd onderwerp dat verder gaat dan het bereik van dit artikel.)

EEN stapel trace is een lijst met alle methoden die door Java zijn doorzocht op zoek naar een uitzonderingshandler. Dit is hoe een stacktrack eruitziet:

Uitzondering in thread "main" java.lang.NullPointerException op com.example.myproject.Book.getTitle (Book.java:16) bij com.example.myproject.Ahorhor.getBookTitles (Author.java:25) bij com.example. myproject.Bootstrap.main (Bootstrap.java:14)

We kunnen hier veel van opsommen. Ten eerste was de gegooide uitzondering a NullPointerException. Het gebeurde in de getTitle () methode op regel 16 van Book.java. Die methode is aangeroepen getBookTitles () op regel 25 van Author.java. Dat methode is aangeroepen hoofd() op regel 14 van Bootstrap.java. Zoals u kunt zien, maakt het kennen van dit alles het debuggen eenvoudiger.

Maar nogmaals, het echte voordeel van uitzonderingen is dat je het kunt “handvat” de abnormale toestand door de uitzondering te vangen, dingen recht te zetten en de toepassing te hervatten zonder te crashen.

Java-uitzonderingen in code gebruiken

Laten we zeggen dat je dat hebt gedaan someMethod () dat een geheel getal vereist en wat logica uitvoert die zou kunnen breken als het gehele getal kleiner is dan 0 of groter dan 100. Dit zou een goede plaats kunnen zijn om een ​​uitzondering te genereren:

public void someMethod (int value) if (value < 0 || value > 100) gooi nieuw IllegalArgumentException();  // ...

Om deze uitzondering te vangen, moet je naar waar gaan someMethod () wordt aangeroepen en gebruikt de try-catch-blok:

public void callingMethod () try someMethod (200); someOtherMethod ();  catch (IllegalArgumentException e) // behandel de uitzondering hier // ...

Alles binnen de proberen blok wordt uitgevoerd totdat een uitzondering wordt gegenereerd. Zodra een uitzondering wordt gegenereerd, worden alle volgende instructies overgeslagen en springt de toepassingslogica onmiddellijk naar de vangst blok.

In ons voorbeeld voeren we het try-blok in en bellen meteen someMethod (). Aangezien 200 niet tussen 0 en 100 ligt, is een IllegalArgumentException wordt gegooid. Dit beëindigt onmiddellijk de uitvoering van someMethod (), slaat de rest van de logica over in het try-blok (someOtherMethod () wordt nooit aangeroepen) en hervat de uitvoering binnen het blok catch.

Wat zou er gebeuren als we belden someMethod (50) in plaats daarvan? De IllegalArgumentException zou nooit worden gegooid. someMethod () zou normaal worden uitgevoerd. Het try-blok zou normaal worden uitgevoerd, bellen someOtherMethod () wanneer someMethod () is voltooid. Wanneer someOtherMethod () eindigt, het blok catch wordt overgeslagen en callingMethod () zou doorgaan.

Merk op dat je meerdere blokkeringen kunt gebruiken per try-blok:

public void callingMethod () try someMethod (200); someOtherMethod ();  catch (IllegalArgumentException e) // behandel de uitzondering in hier catch (NullPointerException e) // behandel de uitzondering hier // ...

Merk ook op dat een optionele Tenslotte blok bestaat ook:

openbare ongeldige methode () try // ... catch (Uitzondering e) // ... eindelijk // ...

De code binnen een uiteindelijk blok is altijd uitgevoerd ongeacht wat. Als u een instructie return in het blok try hebt, wordt het finally-blok uitgevoerd voordat u de methode verlaat. Als u een andere uitzondering in het blok catch gooit, wordt het finally-blok uitgevoerd voordat de uitzondering wordt gegenereerd.

Gebruik het laatste blok als u objecten hebt die moeten worden opgeschoond voordat de methode eindigt. Als u bijvoorbeeld een bestand in het blok try hebt geopend en later een uitzondering hebt gegenereerd, kunt u met het laatste blok het bestand sluiten voordat u de methode verlaat.

Merk op dat je een slot kunt maken zonder een blok catch:

openbare ongeldige methode () try // ... eindelijk // ...

Hiermee kunt u elke noodzakelijke opschoning uitvoeren terwijl gegooide uitzonderingen de methode-aanroepstapel doorgeven (dat wil zeggen u wilt de uitzondering hier niet afhandelen, maar u moet deze eerst opschonen).

Gecontroleerd versus niet-gecontroleerde uitzonderingen in Java

In tegenstelling tot de meeste talen maakt Java onderscheid tussen gecontroleerde uitzonderingen en niet-gecontroleerde uitzonderingen (bijvoorbeeld C # heeft alleen ongecontroleerde uitzonderingen). Een gecontroleerde uitzondering moet vast te zitten in de methode waar de uitzondering wordt gegenereerd of anders zal de code niet compileren.

Als u een gecontroleerde uitzondering wilt maken, breidt u uit vanaf Uitzondering. Als u een niet-gecontroleerde uitzondering wilt maken, gaat u verder vanaf RuntimeException.

Elke methode die een gecontroleerde uitzondering genereert, moet dit aangeven in de methodehandtekening met behulp van de worpen trefwoord. Sinds Java is ingebouwd IOException is een gecontroleerde uitzondering, de volgende code compileert niet:

public void wontCompile () // ... if (someCondition) gooi nieuwe IOException ();  // ...

U moet eerst verklaren dat het een gecontroleerde uitzondering genereert:

public void willCompile () gooit IOException // ... if (someCondition) gooi nieuwe IOException ();  // ...

Merk op dat een methode kan worden gedeclareerd als het gooien van een uitzondering, maar werp nooit een uitzondering. Toch zal de uitzondering nog steeds moeten worden gepakt, anders zal de code niet worden gecompileerd.

Wanneer moet u aangevinkte of niet-gecontroleerde uitzonderingen gebruiken?

De officiële Java-documentatie bevat een pagina over deze vraag. Het vat het verschil samen met een beknopte vuistregel: “Als van een client redelijkerwijs verwacht kan worden dat hij herstelt van een uitzondering, maak er dan een gecontroleerde uitzondering van. Als een client niets kan doen om de uitzondering te herstellen, maak er dan een niet-gecontroleerde uitzondering van.”

Maar deze richtlijn kan verouderd zijn. Aan de ene kant zorgen gecontroleerde uitzonderingen voor meer robuuste code 10 Tips voor het schrijven van Schonere & Betere Code 10 Tips voor het schrijven van Schonere en Betere code Schrijven schone code ziet er eenvoudiger uit dan het in werkelijkheid is, maar de voordelen zijn het waard. Hier leest u hoe u vandaag schonere code kunt gaan schrijven. Lees verder . Aan de andere kant heeft geen enkele andere taal uitzonderingen gecontroleerd op dezelfde manier als Java, wat twee dingen laat zien: een, de functie is niet genoeg bruikbaar voor andere talen om hem te stelen, en twee, je kunt absoluut zonder leven. Bovendien controleren gecontroleerde uitzonderingen niet goed met lambda-expressies die in Java 8 zijn geïntroduceerd.

Richtlijnen voor gebruik van Java-uitzonderingen

Uitzonderingen zijn nuttig, maar gemakkelijk misbruikt en misbruikt. Hier zijn enkele tips en praktische tips om te voorkomen dat u er een puinhoop van maakt.

• Geef de voorkeur aan specifieke uitzonderingen op algemene uitzonderingen. Gebruik NumberFormatException over- IllegalArgumentException indien mogelijk, anders gebruik IllegalArgumentException over- RuntimeException wanneer mogelijk.
• Nooit vangen Throwable! De Uitzondering klasse breidt zich eigenlijk uit Throwable, en het catch-blok werkt eigenlijk met Throwable of elke klasse die Throwable uitbreidt. echter, de Fout klasse breidt zich ook uit Throwable, en je wilt nooit een vangen Fout omdat Fouts geven serieuze, niet-herstelbare problemen aan.
• Nooit vangen Uitzondering! InterruptedException strekt Uitzondering, dus elk blok dat vangt Uitzondering zal ook vangen InterruptedException, en dat is een erg belangrijke uitzondering waar je niet mee wilt rotzooien (vooral in multi-threaded applicaties), tenzij je weet wat je doet. Als je niet weet welke uitzondering je moet vangen, overweeg dan niets te vangen.
• Gebruik beschrijvende berichten om het debuggen te vereenvoudigen. Wanneer je een uitzondering gooit, kun je een Draad bericht als een argument. Dit bericht kan worden geopend in het catch-blok met behulp van de Exception.getMessage () methode, maar als de uitzondering nooit wordt gevangen, verschijnt het bericht ook als onderdeel van de stacktracering.
• Probeer uitzonderingen niet te vangen en te negeren. Om het ongemak van gecontroleerde uitzonderingen te omzeilen, zetten veel newbie en luie programmeurs een catch-blok op, maar laten deze leeg. Slecht! Ga er altijd gracieus mee om, maar als dat niet lukt, druk dan op zijn minst een stapelspoor uit zodat je weet dat de uitzondering is geworpen. U kunt dit doen met behulp van de Exception.printStackTrace () methode.
• Pas op voor het gebruik van uitzonderingen. Als je een hamer hebt, lijkt alles op een spijker. Wanneer u voor het eerst over uitzonderingen leert, kunt u zich verplicht voelen om van alles een uitzondering te maken ... tot het punt waarop het beheer van de meeste toepassingen te maken heeft met het afhandelen van uitzonderingen. Vergeet niet, uitzonderingen zijn bedoeld voor “buitengewoon” voorvallen!

Nu zou je comfortabel genoeg moeten zijn met uitzonderingen om te begrijpen wat ze zijn, waarom ze worden gebruikt en hoe ze in je eigen code kunnen worden verwerkt. Als je het concept niet volledig begrijpt, is dat goed! Het kostte me een tijdje om dat te doen “Klik” in mijn hoofd, dus heb niet het gevoel dat je het moet overhaasten 6 Tekenen dat je niet programmeur wilt zijn 6 Tekens die je niet als een programmeur mag beschouwen Niet iedereen is een programmeur. Als je niet helemaal zeker bent dat je een programmeur moet zijn, zijn hier enkele aanwijzingen die je in de juiste richting kunnen wijzen. Lees verder . Neem je tijd.

Heb je nog vragen? Kent u nog andere uitzonderingsgerelateerde tips die ik heb gemist? Deel ze in de reacties hieronder!

Ontdek meer over: Java.