Hoe om te gaan met Java-uitzonderingen op de juiste manier

Advertentie

Als programmerende beginner Programmeren leren zonder alle stressMisschien heb je besloten om te gaan programmeren, voor een carrière of gewoon als hobby. Super goed! Maar misschien begin je je overweldigd te voelen. Niet zo goed. Hier is hulp om uw reis te vergemakkelijken. Lees verder , het concept van uitzonderingsbehandeling kan moeilijk zijn om je hoofd rond te wikkelen. Niet dat het concept zelf moeilijk is, maar de terminologie kan het geavanceerder doen lijken dan het is. En het is zo'n krachtige functie dat het vatbaar is voor misbruik en misbruik.

In dit artikel leert u wat uitzonderingen zijn, waarom ze belangrijk zijn, hoe u ze gebruikt en veelgemaakte fouten om te vermijden. De meeste moderne talen 6 eenvoudigste programmeertalen om te leren voor beginnersLeren programmeren gaat net zo goed over het vinden van de juiste taal als over het opbouwproces. Hier zijn de zes gemakkelijkste programmeertalen voor beginners. Lees verder een uitzondering hebben, dus als je

ooit overstappen van Java 7 Handige trucs voor het beheersen van een nieuwe programmeertaalHet is prima om overweldigd te worden als je leert programmeren. U vergeet de dingen waarschijnlijk net zo snel als u ze leert. Deze tips kunnen u helpen om al die nieuwe informatie beter te bewaren. Lees verder kunt u de meeste van deze tips meenemen.

Java-uitzonderingen begrijpen

In Java, een uitzondering is een object dat aangeeft dat er iets abnormaals (of 'uitzonderlijks') is opgetreden tijdens het uitvoeren van uw applicatie. Dergelijke uitzonderingen zijn gegooid, wat in feite betekent dat er een uitzonderingsobject wordt gemaakt (vergelijkbaar met hoe fouten worden "gegenereerd").

Het mooie is dat je het kunt vangst uitzonderingen gegenereerd, waarmee u de abnormale toestand kunt afhandelen en uw toepassing kunt laten doorgaan alsof er niets mis is gegaan. Terwijl een null-aanwijzer in C bijvoorbeeld uw toepassing kan laten crashen, kunt u met Java gooien en vangen NullPointerExceptions voordat een null-variabele een kans heeft om een ​​crash te veroorzaken.

Onthoud dat een uitzondering slechts een object is, maar met één belangrijk kenmerk: het moet worden verlengd vanaf de Uitzondering klasse of een subklasse van Uitzondering. Hoewel Java allerlei ingebouwde uitzonderingen heeft, kunt u er ook uw eigen maken als u dat wilt. Sommige van de meest voorkomende Java-uitzonderingen omvatten:

• 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 het soort uitzondering behandelt dat je hebt gegenereerd. Als een handler niet bestaat, kijkt hij naar de methode die de huidige methode heeft aangeroepen om te zien of daar een handle bestaat. Zo niet, dan wordt er gekeken naar de methode die is aangeroepen dat methode, en dan de volgende methode, enz. Als de uitzondering niet wordt opgemerkt, drukt de applicatie een stacktracering af en crasht vervolgens. (Eigenlijk is het genuanceerder dan gewoon crashen, maar dat is een geavanceerd onderwerp dat buiten het bestek van dit artikel valt.)

EEN stack trace is een lijst met alle methoden die Java heeft doorlopen terwijl hij op zoek was naar een uitzonderingshandler. Zo ziet een stacktracering eruit:

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

Hier kunnen we veel van opdoen. Ten eerste was de opgeworpen uitzondering a NullPointerException. Het gebeurde in de getTitle () methode op regel 16 van Book.java. Die methode werd genoemd vanaf getBookTitles () op lijn 25 van Author.java. Dat methode is aangeroepen vanaf hoofd() op lijn 14 van Bootstrap.java. Zoals u kunt zien, wordt het debuggen eenvoudiger als u dit allemaal weet.

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

Java-uitzonderingen in code gebruiken

Laten we zeggen dat je het hebt someMethod () er is een geheel getal voor nodig en er wordt logica uitgevoerd die kan breken als het gehele getal kleiner is dan 0 of groter dan 100. Dit kan een goede plek zijn om een ​​uitzondering te maken:

public void someMethod (int value) {if (value <0 || value> 100) {throw new IllegalArgumentException(); } //... }

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

openbare leegte callingMethod () {probeer {someMethod (200); someOtherMethod (); } catch (IllegalArgumentException e) {// behandel hier de uitzondering} //... }

Alles binnen de proberen blok zal in volgorde worden uitgevoerd totdat er een uitzondering wordt gegenereerd. Zodra er 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 onmiddellijk 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 catch-blok.

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 en zou bellen someOtherMethod () wanneer someMethod () is voltooid. Wanneer someOtherMethod () eindigt, zou het vangblok worden overgeslagen en callingMethod () zou doorgaan.

Merk op dat u meerdere catch-blokken per try-blok kunt hebben:

openbare leegte callingMethod () {probeer {someMethod (200); someOtherMethod (); } catch (IllegalArgumentException e) {// behandel de uitzondering hier} catch (NullPointerException e) {// behandel de uitzondering hier} //... }

Merk ook op dat een optioneel Tenslotte blok bestaat ook:

openbare ongeldige methode () {probeer {//... } catch (uitzondering e) {//... } Tenslotte { //... } }

De code binnen een definitief blok is altijd uitgevoerd wat er ook gebeurt. Als u een return-instructie in het try-blok heeft, wordt het laatste blok uitgevoerd voordat het uit de methode terugkeert. Als je nog een uitzondering in het catch-blok gooit, wordt het laatste blok uitgevoerd voordat de uitzondering wordt gegooid.

Je moet het laatste blok gebruiken als je objecten hebt die moeten worden opgeruimd voordat de methode eindigt. Als u bijvoorbeeld een bestand in het try-blok hebt geopend en later een uitzondering heeft gegenereerd, kunt u met het laatste blok het bestand sluiten voordat u de methode verlaat.

Merk op dat je een definitief blok kunt hebben zonder een catch-blok:

openbare ongeldige methode () {probeer {//... } Tenslotte { //... } }

Hiermee kunt u de nodige opruimingen uitvoeren, terwijl u met de gemaakte uitzonderingen de methode kunt uitdragen aanroepstapel (d.w.z. u wilt de uitzondering hier niet afhandelen, maar u moet nog steeds opschonen) eerste).

Gecontroleerd vs. Niet-gecontroleerde uitzonderingen in Java

In tegenstelling tot de meeste talen maakt Java onderscheid tussen gecontroleerde uitzonderingen en ongecontroleerde uitzonderingen (bijv. C # heeft alleen ongecontroleerde uitzonderingen). Een gecontroleerde uitzondering moet betrapt worden op de methode waarbij de uitzondering wordt gegenereerd, anders wordt de code niet gecompileerd.

Verleng vanaf om een ​​gecontroleerde uitzondering te maken Uitzondering. Verleng vanaf om een ​​niet-aangevinkte uitzondering te maken RuntimeException.

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

openbare leegte wontCompile () {//... if (someCondition) {gooi nieuwe IOException (); } //... }

U moet eerst verklaren dat er een gecontroleerde uitzondering wordt gegenereerd:

openbare leegte willCompile () gooit IOException {//... if (someCondition) {gooi nieuwe IOException (); } //... }

Merk op dat een methode kan worden gedeclareerd als het werpen van een uitzondering, maar eigenlijk nooit een uitzondering werpen. Toch moet de uitzondering nog steeds worden opgevangen, anders wordt de code niet gecompileerd.

Wanneer moet u gecontroleerde of niet-gecontroleerde uitzonderingen gebruiken?

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

Maar deze richtlijn is mogelijk verouderd. Enerzijds zijn gecontroleerde uitzonderingen dat wel resulteren in meer robuuste code 10 tips voor het schrijven van schonere en betere codeSchone code schrijven lijkt eenvoudiger dan het in werkelijkheid is, maar de voordelen zijn het waard. Hier leest u hoe u vandaag kunt beginnen met het schrijven van schonere code. Lees verder . Aan de andere kant heeft geen enkele andere taal uitzonderingen op dezelfde manier gecontroleerd als Java, wat twee dingen laat zien: ten eerste is de functie niet nuttig genoeg voor andere talen om hem te stelen, en ten tweede kun je absoluut zonder leven hen. Bovendien spelen gecontroleerde uitzonderingen niet goed samen met lambda-expressies die in Java 8 zijn geïntroduceerd.

Richtlijnen voor het gebruik van Java-uitzonderingen

Uitzonderingen zijn nuttig, maar kunnen gemakkelijk worden misbruikt en misbruikt. Hier zijn een paar tips en praktische tips om te voorkomen dat je er een zooitje van maakt.

• Geef de voorkeur aan specifieke uitzonderingen boven algemene uitzonderingen. Gebruik NumberFormatException over- IllegalArgumentException indien mogelijk, anders gebruik IllegalArgumentException over- RuntimeException wanneer mogelijk.
• Nooit vangen Gooi! De Uitzondering klasse breidt zich eigenlijk uit Gooi, en het catch-blok werkt eigenlijk mee Gooi of een klasse die Throwable uitbreidt. echter, de Fout klasse breidt zich ook uit Gooi, en je wilt nooit een vangen Fout omdat Fouts duiden op ernstige onherstelbare problemen.
• Nooit vangen Uitzondering!Onderbroken uitzondering breidt zich uit Uitzondering, dus elk blok dat vangt Uitzondering zal ook vangen Onderbroken uitzondering, en dat is een zeer belangrijke uitzondering waar je niet mee wilt rommelen (vooral in applicaties met meerdere threads) tenzij je weet wat je doet. Als u niet weet welke uitzondering u moet opvangen, overweeg dan niets te vangen.
• Gebruik beschrijvende berichten om foutopsporing te vergemakkelijken. Wanneer u een uitzondering genereert, kunt u een Draad bericht als argument. Dit bericht is toegankelijk in het catch-blok met behulp van de Exception.getMessage () methode, maar als de uitzondering nooit wordt opgemerkt, wordt het bericht ook weergegeven als onderdeel van de stacktracering.
• Probeer uitzonderingen niet te vangen en te negeren. Om het ongemak van gecontroleerde uitzonderingen te omzeilen, zullen veel nieuwe en luie programmeurs een catch-blok opzetten, maar dit leeg laten. Slecht! Ga er altijd netjes mee om, maar als je dat niet kunt, druk dan op zijn minst een stacktracering af, zodat je weet dat de uitzondering is gegenereerd. U kunt dit doen met de Exception.printStackTrace () methode.
• Pas op voor uitzonderingen die te veel worden gebruikt. Als je een hamer hebt, ziet alles eruit als een spijker. Wanneer u voor het eerst over uitzonderingen leert, voelt u zich misschien verplicht om alles in een uitzondering te veranderen... tot het punt waarop het grootste deel van de controlestroom van uw applicatie neerkomt op het afhandelen van uitzonderingen. Onthoud dat uitzonderingen bedoeld zijn voor "uitzonderlijke" gebeurtenissen!

Nu zou u vertrouwd moeten zijn met uitzonderingen om te begrijpen wat ze zijn, waarom ze worden gebruikt en hoe u ze in uw eigen code kunt opnemen. Als je het concept niet volledig begrijpt, is dat oké! Het duurde even voordat het in mijn hoofd 'klikte', dus heb niet het gevoel dat je het moet haasten 6 tekenen dat u niet bedoeld bent om programmeur te zijnNiet iedereen is bedoeld als programmeur. Als u niet helemaal zeker weet of u programmeur wilt worden, volgen hier enkele aanwijzingen die u in de goede richting kunnen wijzen. Lees verder . Neem je tijd.

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