Eccezioni: selezionata, non selezionata e personalizzata

CIAO! Nell'ultima lezione, abbiamo familiarizzato con le eccezioni nel linguaggio Java e abbiamo visto esempi su come lavorarci. Oggi daremo uno sguardo più approfondito alla struttura delle eccezioni e impareremo a scrivere le nostre eccezioni :)

Tipi di eccezioni

Come abbiamo detto in precedenza, ci sono molte eccezioni in Java, quasi 400! Ma sono tutti divisi in gruppi, quindi è abbastanza facile ricordarli. Ecco come appare: tutte le eccezioni hanno un antenato comune nella Throwableclasse. Ne derivano due gruppi principali: eccezioni ( Exception ) ed errori ( Error ). Errore : rappresenta un errore critico in fase di esecuzione relativo al funzionamento della macchina virtuale Java. Nella maggior parte dei casi, Error non ha bisogno di essere gestito, poiché indica alcuni seri difetti nel codice. I più famosi di questi sono StackOverflowError (questo si verifica, ad esempio, quando un metodo chiama se stesso all'infinito) e OutOfMemoryError(questo si verifica quando non c'è memoria sufficiente per creare nuovi oggetti). Come puoi vedere, in queste situazioni, di solito non c'è assolutamente nulla da gestire in fase di esecuzione: il codice è semplicemente scritto in modo errato e deve essere rielaborato. Eccezione - Questo rappresenta, beh, un'eccezione: una situazione eccezionale e non pianificata che si verifica mentre il programma è in esecuzione. Non sono gravi come Error, ma richiedono comunque la nostra attenzione. Tutte le eccezioni sono divise in 2 tipi: controllate e non controllate . Tutte le eccezioni verificate derivano dalla Exceptionclasse. Cosa significa "controllato"? Abbiamo accennato a questo nell'ultima lezione: "Il compilatore Java conosce quindi le eccezioni più comuni e le situazioni in cui potrebbero verificarsi". Ad esempio, sa che se il codice legge i dati da un file, il file potrebbe facilmente non esistere. E ci sono molte di queste situazioni (che può dedurre). Di conseguenza, il compilatore controlla in anticipo il nostro codice per la presenza di queste potenziali eccezioni. Se li trova, non compilerà il codice finché non li avremo gestiti o rilanciati. Il secondo tipo di eccezione è "non controllato". Derivano dalla RuntimeExceptionclasse. In che modo differiscono dalle eccezioni verificate? Sembra che ci siano anche molte classi diverse derivate daRuntimeException(che descrivono le eccezioni di runtime). La differenza è che il compilatore non prevede questi errori. Sembra dire: "Quando il codice è stato scritto, non ho trovato nulla di sospetto, ma qualcosa è andato storto mentre era in esecuzione. A quanto pare, ci sono errori nel codice!" E infatti questo è vero. Le eccezioni non controllate sono molto spesso il risultato di errori del programmatore. E il compilatore ovviamente non può prevedere ogni possibile brutta situazione che le persone potrebbero creare con le proprie mani. :) Pertanto, non controlla se tali eccezioni sono gestite nel nostro codice. Hai già riscontrato diverse eccezioni non verificate:

• Un'ArithmeticException si verifica quando si divide per zero
• Un'eccezione ArrayIndexOutOfBoundsException si verifica quando si tenta di accedere a una posizione esterna all'array.

Naturalmente, puoi immaginare che i creatori di Java avrebbero potuto introdurre la gestione obbligatoria delle eccezioni, ma in questo caso il codice sarebbe troppo complicato. Per qualsiasi operazione di divisione, dovresti scrivere un try-catchblocco per verificare se hai accidentalmente diviso per zero? Ogni volta che accedi a un array, dovresti scrivere un try-catchblocco per verificare se il tuo indice era fuori limite. Tutto sarebbe codice spaghetti e sarebbe completamente illeggibile. Ha senso che questa idea sia stata abbandonata. Di conseguenza, le eccezioni non controllate non devono essere gestite in try-catchblocchi o rilanciate (sebbene ciò sia tecnicamente possibile, come con Error).

Come lanciare la tua eccezione

Naturalmente, i creatori di Java non possono prevedere tutte le situazioni eccezionali che potrebbero verificarsi nei programmi. Ci sono troppi programmi nel mondo e sono troppo diversi. Ma questo non è nulla di cui preoccuparsi, perché puoi creare la tua eccezione, se necessario. Questo è molto facile da fare. Tutto quello che devi fare è creare la tua classe. Dovresti essere sicuro che il suo nome finisca con "Exception". Il compilatore non lo richiede, ma altri programmatori che leggono il tuo codice capiranno immediatamente che si tratta di una classe di eccezione. Inoltre, indicare che la classe è ereditata dalla Exceptionclasse (il compilatore lo richiede). Ad esempio, supponiamo di avere una Dogclasse. Possiamo portare a spasso il cane usando ilwalk()metodo. Ma prima di farlo, dobbiamo verificare se il nostro animale indossa collare, guinzaglio e museruola. Se manca uno di questi attrezzi, lanciamo la nostra eccezione: DogIsNotReadyException . Il suo codice è simile a questo:

public class DogIsNotReadyException extends Exception {

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

Per indicare che la classe è un'eccezione, è necessario scrivere " extends Exception " dopo il nome della classe (questo significa "la classe è derivata dalla classe Exception"). Nel costruttore, chiamiamo semplicemente il Exceptioncostruttore della classe con il messaggio String (se si verifica l'eccezione, mostreremo all'utente il messaggio, una descrizione dell'errore). Ecco come appare nel nostro codice di classe:

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

}

Ora il nostro walk()metodo genera un'eccezione DogIsNotReadyException . Questo viene fatto con la parola chiave throw. Come abbiamo detto prima, un'eccezione è un oggetto. Quindi, quando si verifica un'eccezione (al cane manca qualcosa) nel nostro metodo, creiamo un nuovo DogIsNotReadyExceptionoggetto e lo lanciamo usando la parola chiave throw. Aggiungiamo " getta DogIsNotReadyException " alla dichiarazione del metodo. In altre parole, ora il compilatore è consapevole che chiamare il walk()metodo potrebbe trasformarsi in una situazione eccezionale. Di conseguenza, questa eccezione deve essere gestita se chiamiamo questo metodo da qualche parte nel nostro programma. Proviamo a farlo nel main()metodo:

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

Questo non verrà compilato. L'eccezione non viene gestita! Avvolgiamo il nostro codice in un try-catchblocco per gestire l'eccezione:

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

Ora diamo un'occhiata all'output della console: Il collare è acceso! La museruola è accesa! Ci stiamo preparando per una passeggiata! Buddy non è pronto per una passeggiata! Controlla la marcia! Controllo della marcia! Il collare è allacciato? true Il guinzaglio è allacciato? false La museruola è inserita? true Guarda quanto più informativo è stato l'output della console! Vediamo ogni passo compiuto nel programma; vediamo dove si è verificato l'errore e possiamo anche vedere immediatamente esattamente cosa manca al nostro cane. :) Ed è così che crei le tue eccezioni. Come puoi vedere, non c'è niente di complicato in questo. E anche se i creatori di Java non si sono presi la briga di includere nel linguaggio un'eccezione speciale per i cani poco equipaggiati, abbiamo corretto la loro svista. :)