Undantag: markerad, omarkerad och anpassad

Hej! På förra lektionen bekantade vi oss med undantag i Java-språket, och såg exempel på hur man kan arbeta med dem. Idag ska vi ta en djupare titt på strukturen för undantag och lära oss hur man skriver våra egna undantag :)

Typer av undantag

Som vi sa tidigare finns det många undantag i Java, nästan 400! Men de är alla indelade i grupper, så det är ganska lätt att komma ihåg dem. Så här ser det ut: Alla undantag har en gemensam anfader i Throwableklassen. Två huvudgrupper härleds från det: undantag ( Undantag ) och fel ( Fel ). Fel - Detta representerar ett kritiskt körtidsfel relaterat till driften av den virtuella Java-maskinen. I de flesta fall behöver fel inte hanteras, eftersom det indikerar några allvarliga brister i koden. De mest kända av dessa är StackOverflowError (detta inträffar till exempel när en metod kallar sig oändligt) och OutOfMemoryError(detta inträffar när det inte finns tillräckligt med minne för att skapa nya objekt). Som du kan se, i dessa situationer, finns det vanligtvis absolut ingenting att hantera under körning: koden är helt enkelt felaktigt skriven och måste omarbetas. Undantag - Detta representerar, ja, ett undantag: en exceptionell, oplanerad situation som inträffar medan programmet körs. De är inte lika allvarliga som Error, men de kräver fortfarande vår uppmärksamhet. Alla undantag är indelade i 2 typer: markerad och omarkerad . Alla markerade undantag härleds från Exceptionklassen. Vad betyder "kontrollerad"? Vi anspelade på detta i förra lektionen: "Java-kompilatorn känner därför till de vanligaste undantagen och de situationer där de kan uppstå." Till exempel vet den att om koden läser data från en fil kan filen lätt inte existera. Och det finns många sådana situationer (som det kan dra slutsatsen). Följaktligen kontrollerar kompilatorn vår kod i förväg för förekomsten av dessa potentiella undantag. Om den hittar dem kommer den inte att kompilera koden förrän vi har hanterat dem eller kastat dem igen. Den andra typen av undantag är "avmarkerad". De kommer från RuntimeExceptionklassen. Hur skiljer de sig från markerade undantag? Det verkar som att det också finns massor av olika klasser som härrör frånRuntimeException(som beskriver körtidsundantag). Skillnaden är att kompilatorn inte förutser dessa fel. Det verkar säga: "När koden skrevs hittade jag inget misstänkt, men något gick fel när den kördes. Tydligen finns det fel i koden!" Och detta är verkligen sant. Omarkerade undantag är oftast resultatet av programmeringsfel. Och kompilatorn kan uppenbarligen inte förutse alla möjliga dåliga situationer som människor kan skapa med sina egna händer. :) Därför kontrollerar den inte om sådana undantag hanteras i vår kod. Du har redan stött på flera omarkerade undantag:

• Ett aritmetiskt undantag uppstår när man dividerar med noll
• Ett ArrayIndexOutOfBoundsException uppstår när du försöker komma åt en position utanför arrayen.

Visst kan man tänka sig att Javas skapare kunde ha infört obligatorisk undantagshantering, men i det här fallet skulle koden vara för komplicerad. För varje divisionsoperation, skulle du behöva skriva ett try-catchblock för att kontrollera om du av misstag dividerat med noll? Varje gång du öppnade en array måste du skriva ett try-catchblock för att kontrollera om ditt index var utanför gränserna. Allt skulle vara spagettikod och skulle vara helt oläsligt. Det är logiskt att denna idé övergavs. Som ett resultat behöver omarkerade undantag inte hanteras i try-catchblock eller kastas om (även om detta är tekniskt möjligt, som med Error).

Hur man gör ett eget undantag

Naturligtvis kan Javas skapare inte förutse varje exceptionell situation som kan uppstå i program. Det finns för många program i världen, och de är för olika. Men det här är inget att oroa sig för, eftersom du kan skapa ditt eget undantag om det behövs. Detta är väldigt lätt att göra. Allt du behöver göra är att skapa din egen klass. Du bör vara säker på att dess namn slutar med "Undantag". Kompilatorn kräver inte detta, men andra programmerare som läser din kod kommer omedelbart att förstå att det är en undantagsklass. Ange dessutom att klassen ärvs från Exceptionklassen (kompilatorn kräver detta). Anta till exempel att vi har en Dogklass. Vi kan gå ut med hunden med hjälp avwalk()metod. Men innan vi gör det måste vi kontrollera om vårt husdjur har halsband, koppel och nos. Om någon av den här utrustningen saknas, gör vi vårt eget undantag: DogIsNotReadyException . Dess kod ser ut så här:

public class DogIsNotReadyException extends Exception {

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

För att indikera att klassen är ett undantag måste du skriva " extends Exception " efter klassnamnet (detta betyder "klassen är härledd från klassen Exception"). I konstruktorn anropar vi helt enkelt klasskonstruktorn Exceptionmed String -meddelandet (om undantaget inträffar kommer vi att visa meddelandet, en beskrivning av felet, för användaren). Så här ser det ut i vår klasskod:

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!");
   }
 }

}

Nu walk()ger vår metod en DogIsNotReadyException . Detta görs med nyckelordet throw. Som vi sa tidigare är ett undantag ett objekt. Så när ett undantag inträffar (hunden saknar något) i vår metod skapar vi ett nytt DogIsNotReadyExceptionobjekt och kastar det med nyckelordet throw. Vi lägger till " kastar DogIsNotReadyException " till metoddeklarationen. Med andra ord, nu är kompilatorn medveten om att anrop av walk()metoden kan förvandlas till en exceptionell situation. Följaktligen måste detta undantag hanteras om vi anropar denna metod någonstans i vårt program. Låt oss försöka göra detta i main()metoden:

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

Det här kommer inte att kompileras. Undantaget hanteras inte! Vi slår in vår kod i ett try-catchblock för att hantera undantaget:

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

Låt oss nu titta på konsolutgången: Kragen är på! Nospartiet är på! Vi gör oss redo för en promenad! Buddy är inte redo för en promenad! Kolla utrustningen! Kollar utrustningen! Är kragen på? sant Är kopplet på? false Är nospartiet på? sant Titta på hur mycket mer informativ konsolutgången var! Vi ser varje steg som tas i programmet; vi ser var felet uppstod, och vi kan också direkt se exakt vad vår hund saknar. :) Och det är så man skapar sina egna undantag. Som du kan se är det inget komplicerat med det. Och även om Javas skapare inte brydde sig om att inkludera ett särskilt undantag i språket för dåligt utrustade hundar, har vi åtgärdat deras tillsyn. :)