Uitzonderingen: aangevinkt, niet aangevinkt en aangepast

Hoi! In de laatste les hebben we kennis gemaakt met uitzonderingen in de Java-taal en voorbeelden gezien van hoe ermee te werken. Vandaag gaan we dieper in op de structuur van uitzonderingen en leren we hoe we onze eigen uitzonderingen kunnen schrijven :)

Soorten uitzonderingen

Zoals we eerder zeiden, zijn er veel uitzonderingen op Java, bijna 400! Maar ze zijn allemaal onderverdeeld in groepen, dus het is vrij eenvoudig om ze te onthouden. Zo ziet het eruit: Alle uitzonderingen hebben een gemeenschappelijke voorouder in de Throwableklas. Er zijn twee hoofdgroepen van afgeleid: uitzonderingen ( Exception ) en fouten ( Error ). Error - Dit vertegenwoordigt een kritieke runtime-fout met betrekking tot de werking van de virtuele Java-machine. In de meeste gevallen hoeft Error niet te worden afgehandeld, omdat het een aantal ernstige fouten in de code aangeeft. De bekendste hiervan zijn StackOverflowError (dit gebeurt bijvoorbeeld wanneer een methode zichzelf eindeloos aanroept) en OutOfMemoryError(dit gebeurt wanneer er onvoldoende geheugen is om nieuwe objecten te maken). Zoals u kunt zien, is er in deze situaties meestal absoluut niets te doen tijdens runtime: de code is gewoon verkeerd geschreven en moet worden herwerkt. Uitzondering - Dit vertegenwoordigt, nou ja, een uitzondering: een uitzonderlijke, ongeplande situatie die optreedt terwijl het programma wordt uitgevoerd. Ze zijn niet zo ernstig als Error, maar ze hebben nog steeds onze aandacht nodig. Alle uitzonderingen zijn onderverdeeld in 2 typen: aangevinkt en niet aangevinkt . Alle aangevinkte uitzonderingen zijn afgeleid van de Exceptionklasse. Wat betekent "gecontroleerd"? We zinspeelden hierop in de vorige les: "De Java-compiler kent dus de meest voorkomende uitzonderingen en de situaties waarin deze zich kunnen voordoen." Het weet bijvoorbeeld dat als de code gegevens uit een bestand leest, het bestand gemakkelijk niet kan bestaan. En er zijn veel van dergelijke situaties (die het kan afleiden). Dienovereenkomstig controleert de compiler onze code vooraf op de aanwezigheid van deze mogelijke uitzonderingen. Als het ze vindt, zal het de code niet compileren totdat we ze hebben afgehandeld of opnieuw hebben gegooid. Het tweede type uitzondering is "niet aangevinkt". Ze zijn afgeleid van de RuntimeExceptionklasse. Hoe verschillen ze van gecontroleerde uitzonderingen? Het lijkt erop dat er ook veel verschillende klassen van zijn afgeleidRuntimeException(die runtime-uitzonderingen beschrijven). Het verschil is dat de compiler deze fouten niet anticipeert. Het lijkt te zeggen: "Toen de code werd geschreven, vond ik niets verdachts, maar er ging iets mis tijdens het uitvoeren. Blijkbaar zitten er fouten in de code!" En inderdaad, dit is waar. Ongecontroleerde uitzonderingen zijn meestal het gevolg van programmeerfouten. En de compiler kan natuurlijk niet elke mogelijke slechte situatie voorzien die mensen met hun eigen handen zouden kunnen creëren. :) Daarom wordt niet gecontroleerd of dergelijke uitzonderingen in onze code worden behandeld. U bent al verschillende ongecontroleerde uitzonderingen tegengekomen:

• Een ArithmeticException treedt op bij het delen door nul
• Een ArrayIndexOutOfBoundsException treedt op wanneer u toegang probeert te krijgen tot een positie buiten de array.

Je kunt je natuurlijk voorstellen dat de makers van Java verplichte afhandeling van uitzonderingen hadden kunnen invoeren, maar in dit geval zou de code te gecompliceerd zijn. Zou je voor elke delingsoperatie een try-catchblok moeten schrijven om te controleren of je per ongeluk door nul hebt gedeeld? Telkens wanneer u een array benaderde, zou u een blok moeten schrijven try-catchom te controleren of uw index buiten de grenzen was. Alles zou spaghetticode zijn en totaal onleesbaar. Logisch dat dit idee werd losgelaten. Als gevolg hiervan hoeven niet-gecontroleerde uitzonderingen niet in try-catchblokken te worden afgehandeld of opnieuw te worden gegooid (hoewel dit technisch mogelijk is, zoals bij Error).

Hoe u uw eigen uitzondering gooit

Natuurlijk kunnen de makers van Java niet elke uitzonderlijke situatie voorzien die zich in programma's kan voordoen. Er zijn te veel programma's in de wereld en ze zijn te divers. Maar dit is niets om je zorgen over te maken, omdat je indien nodig je eigen uitzondering kunt maken. Dit is heel gemakkelijk te doen. Het enige wat je hoeft te doen is je eigen klasse aan te maken. U moet er zeker van zijn dat de naam eindigt op "Uitzondering". De compiler vereist dit niet, maar andere programmeurs die uw code lezen, zullen onmiddellijk begrijpen dat het een uitzonderingsklasse is. Geef daarnaast aan dat de klasse geërfd is van de Exceptionklasse (de compiler vereist dit wel). Stel dat we een Dogklas hebben. We kunnen de hond uitlaten met behulp van dewalk()methode. Maar voordat we dat doen, moeten we controleren of ons huisdier een halsband, riem en muilkorf draagt. Als een van deze uitrustingen ontbreekt, gooien we onze eigen uitzondering: DogIsNotReadyException . De code ziet er als volgt uit:

public class DogIsNotReadyException extends Exception {

   public DogIsNotReadyException(String message) {
       super(message);
   }
}

Om aan te geven dat de klasse een uitzondering is, moet u " extends Exception " achter de klassenaam schrijven (dit betekent "de klasse is afgeleid van de Exception-klasse"). In de constructor roepen we gewoon de Exceptionklassenconstructor aan met het String- bericht (als de uitzondering optreedt, tonen we het bericht, een beschrijving van de fout, aan de gebruiker). Dit ziet er als volgt uit in onze klassencode:

public class Dog {

   String name;
   boolean isCollarPutOn;
   boolean isLeashPutOn;
   boolean isMuzzlePutOn;


   public Dog(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

   }

   public void putCollar() {

       System.out.println("The collar is on!");
       this.isCollarPutOn = true;
   }

   public void putLeash() {

       System.out.println("The leash is on!");
       this.isLeashPutOn = true;
   }

   public void putMuzzle() {
       System.out.println("The muzzle is on!");
       this.isMuzzlePutOn = true;
   }

   public void walk() throws DogIsNotReadyException {

   System.out.println("We're getting ready for a walk!");
   if (isCollarPutOn && isLeashPutOn && isMuzzlePutOn) {
       System.out.println("Hooray, let's go for a walk! " + name + " is very happy!");
   } else {
       throw new DogIsNotReadyException(name + " is not ready for a walk! Check the gear!");
   }
 }

}

walk()Nu gooit onze methode een DogIsNotReadyException . Dit doe je met het trefwoord throw. Zoals we eerder zeiden, een uitzondering is een object. Dus als er een uitzondering optreedt (de hond mist iets) in onze methode, maken we een nieuw DogIsNotReadyExceptionobject en gooien we het met behulp van het trefwoord worp. We voegen " throws DogIsNotReadyException " toe aan de methodedeclaratie. Met andere woorden, de compiler is zich er nu van bewust dat het aanroepen van de walk()methode een uitzonderlijke situatie kan worden. Daarom moet deze uitzondering worden afgehandeld als we deze methode ergens in ons programma aanroepen. Laten we proberen dit te doen in de main()methode:

public static void main(String[] args) {
  
   Dog dog = new Dog("Buddy");
   dog.putCollar();
   dog.putMuzzle();
   dog.walk();// Unhandled exception: DogIsNotReadyException
}

Dit compileert niet. De uitzondering wordt niet behandeld! We verpakken onze code in een try-catchblok om de uitzondering af te handelen:

public static void main(String[] args) {

   Dog dog = new Dog("Buddy");
   dog.putCollar();
   dog.putMuzzle();
   try {
       dog.walk();
   } catch (DogIsNotReadyException e) {
       System.out.println(e.getMessage());
       System.out.println("Checking the gear! Is the collar on? " + dog.isCollarPutOn + "\r\n Is the leash on? "
       + dog.isLeashPutOn + "\r\n Is the muzzle on? " + dog.isMuzzlePutOn);
   }
}

Laten we nu eens kijken naar de console-uitvoer: de halsband is aan! De muilkorf zit erop! We maken ons klaar voor een wandeling! Buddy is niet klaar voor een wandeling! Controleer de uitrusting! Tandwiel controleren! Zit de halsband om? waar Is de riem aan? false Zit de muilkorf erop? true Kijk eens hoeveel informatiever de console-uitvoer was! We zien elke stap die in het programma wordt gezet; we zien waar de fout is opgetreden en we kunnen ook meteen zien wat onze hond precies mist. :) En zo creëer je je eigen uitzonderingen. Zoals je kunt zien, is er niets ingewikkelds aan. En hoewel de makers van Java niet de moeite hebben genomen om in de taal een speciale uitzondering op te nemen voor slecht uitgeruste honden, hebben we hun onoplettendheid verholpen. :)