Excepții: bifat, nebifat și personalizat

Bună! În ultima lecție, ne-am familiarizat cu excepțiile din limbajul Java și am văzut exemple despre cum să lucrăm cu ele. Astăzi vom arunca o privire mai profundă asupra structurii excepțiilor și vom învăța cum să ne scriem propriile excepții :)

Tipuri de excepții

După cum am spus anterior, există o mulțime de excepții în Java, aproape 400! Dar toate sunt împărțite în grupuri, așa că este destul de ușor să le amintiți. Așa arată: Toate excepțiile au un strămoș comun în Throwableclasă. Din el derivă două grupuri majore: excepții ( Excepție ) și erori ( Eroare ). Eroare - Aceasta reprezintă o eroare critică de rulare legată de funcționarea mașinii virtuale Java. În cele mai multe cazuri, Eroare nu trebuie să fie tratată, deoarece indică unele defecte grave în cod. Cele mai faimoase dintre acestea sunt StackOverflowError (acest lucru se întâmplă, de exemplu, când o metodă se autoapelează la nesfârșit) și OutOfMemoryError(acest lucru se întâmplă atunci când nu există suficientă memorie pentru a crea obiecte noi). După cum puteți vedea, în aceste situații, de obicei, nu există absolut nimic de gestionat în timpul execuției: codul este pur și simplu scris incorect și trebuie reluat. Excepție - Aceasta reprezintă, ei bine, o excepție: o situație excepțională, neplanificată, care apare în timp ce programul rulează. Nu sunt la fel de grave ca Error, dar încă necesită atenția noastră. Toate excepțiile sunt împărțite în 2 tipuri: bifate și nebifate . Toate excepțiile verificate sunt derivate din Exceptionclasă. Ce înseamnă „verificat”? Am făcut aluzie la acest lucru în ultima lecție: „Compilatorul Java, prin urmare, cunoaște cele mai frecvente excepții și situațiile în care acestea ar putea apărea”. De exemplu, știe că dacă codul citește date dintr-un fișier, fișierul ar putea să nu existe cu ușurință. Și există o mulțime de astfel de situații (pe care le poate deduce). În consecință, compilatorul verifică codul nostru în avans pentru prezența acestor potențiale excepții. Dacă le găsește, nu va compila codul până când nu le vom gestiona sau le-am aruncat din nou. Al doilea tip de excepție este „nebifat”. Ele sunt derivate din RuntimeExceptionclasă. Prin ce sunt diferite de excepțiile verificate? Se pare că există și o mulțime de clase diferite derivate dinRuntimeException(care descriu excepțiile de rulare). Diferența este că compilatorul nu anticipează aceste erori. Se pare că spune: „Când a fost scris codul, nu am găsit nimic suspect, dar ceva a mers prost în timp ce rula. Aparent, există erori în cod!” Și într-adevăr acest lucru este adevărat. Excepțiile neverificate sunt cel mai adesea rezultatul erorilor programatorului. Și compilatorul, evident, nu poate prevedea toate situațiile proaste posibile pe care oamenii le-ar crea cu propriile mâini. :) Prin urmare, nu verifică dacă astfel de excepții sunt gestionate în codul nostru. Ați întâlnit deja câteva excepții nebifate:

• O ArithmeticException apare la împărțirea la zero
• O excepție ArrayIndexOutOfBoundsException apare atunci când încercați să accesați o poziție din afara matricei.

Desigur, vă puteți imagina că creatorii lui Java ar fi putut introduce gestionarea obligatorie a excepțiilor, dar în acest caz codul ar fi prea complicat. Pentru orice operațiune de împărțire, ar trebui să scrieți un try-catchbloc pentru a verifica dacă ați împărțit accidental la zero? De fiecare dată când accesați o matrice, va trebui să scrieți un try-catchbloc pentru a verifica dacă indexul dvs. a fost în afara limitelor. Totul ar fi cod spaghete și ar fi complet ilizibil. Este logic că această idee a fost abandonată. Ca urmare, excepțiile neverificate nu trebuie să fie tratate în try-catchblocuri sau aruncate din nou (deși acest lucru este posibil din punct de vedere tehnic, ca și în cazul erorii).

Cum să arunci propria excepție

Desigur, creatorii Java nu pot prevedea orice situație excepțională care ar putea apărea în programe. Există prea multe programe în lume și sunt prea diverse. Dar acest lucru nu este de ce să vă faceți griji, pentru că vă puteți crea propria excepție, dacă este necesar. Acest lucru este foarte ușor de făcut. Tot ce trebuie să faci este să-ți creezi propria clasă. Ar trebui să vă asigurați că numele său se termină cu „Excepție”. Compilatorul nu necesită acest lucru, dar alți programatori care vă citesc codul vor înțelege imediat că este o clasă de excepție. În plus, indicați că clasa este moștenită de la Exceptionclasă (compilatorul necesită acest lucru). De exemplu, să presupunem că avem o Dogclasă. Putem plimba câinele folosindwalk()metodă. Dar înainte de a face asta, trebuie să verificăm dacă animalul nostru de companie poartă guler, lesă și bot. Dacă vreunul dintre aceste echipamente lipsește, vom arunca propria noastră excepție: DogIsNotReadyException . Codul său arată astfel:

public class DogIsNotReadyException extends Exception {

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

Pentru a indica faptul că clasa este o excepție, trebuie să scrieți „ extinde Exception ” după numele clasei (aceasta înseamnă „clasa este derivată din clasa Excepție”). În constructor, pur și simplu apelăm Exceptionconstructorul clasei cu mesajul String (dacă apare o excepție, vom afișa utilizatorului mesajul, o descriere a erorii). Iată cum arată acest lucru în codul clasei noastre:

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

}

Acum walk()metoda noastră aruncă o excepție DogIsNotReadyException . Acest lucru se face cu cuvântul cheie throw. După cum am spus mai devreme, o excepție este un obiect. Deci, când apare o excepție (câinelui îi lipsește ceva) în metoda noastră, creăm un nou DogIsNotReadyExceptionobiect și îl aruncăm folosind cuvântul cheie throw. Adăugăm „ throws DogIsNotReadyException ” la declarația metodei. Cu alte cuvinte, acum compilatorul este conștient de faptul că apelarea walk()metodei se poate transforma într-o situație excepțională. În consecință, această excepție trebuie gestionată dacă numim această metodă undeva în programul nostru. Să încercăm să facem acest lucru în main()metoda:

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

Aceasta nu se va compila. Excepția nu este gestionată! Ne înfășurăm codul într-un try-catchbloc pentru a gestiona excepția:

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

Acum să ne uităm la ieșirea consolei: gulerul este pus! Botul este pornit! Ne pregătim de plimbare! Buddy nu este gata de plimbare! Verificați echipamentul! Verificarea angrenajului! Gulerul este pus? adevărat Este pusă lesa? false Botul este pus? adevărat Uită-te la cât de informativă a fost rezultatul consolei! Vedem fiecare pas făcut în program; vedem unde a apărut eroarea și, de asemenea, putem vedea imediat ce lipsește câinele nostru. :) Și așa îți creezi propriile excepții. După cum puteți vedea, nu este nimic complicat. Și chiar dacă creatorii Java nu s-au obosit să includă în limbaj o excepție specială pentru câinii prost echipați, le-am remediat supravegherea. :)