Eccezioni: selezionato, non selezionato e tuo

Ciao! Nell'ultima lezione, abbiamo conosciuto questo aspetto del linguaggio Java come eccezioni e abbiamo visto esempi di come lavorare con loro. Oggi daremo uno sguardo più approfondito alla loro struttura e impareremo anche come scrivere le nostre eccezioni :)

Tipi di eccezioni

Come abbiamo detto, le classi di eccezione in Java sono tantissime, quasi 400! Ma sono tutti divisi in gruppi, quindi è abbastanza facile ricordarli. Ecco come appare: tutte le eccezioni hanno una classe antenata comune Throwable. Ne derivano due grandi gruppi: eccezioni (Eccezione) ed errori (Errore). L'errore è un errore critico durante l'esecuzione del programma associato al funzionamento della Java virtual machine. Nella maggior parte dei casi, Error non necessita di essere gestito, poiché indica alcuni gravi difetti nel codice. Gli errori più famosi: StackOverflowError- si verificano, ad esempio, quando un metodo richiama se stesso all'infinito, e OutOfMemoryError- si verificano quando non c'è abbastanza memoria per creare nuovi oggetti. Come puoi vedere, in queste situazioni, molto spesso non c'è nulla di speciale da elaborare: il codice è semplicemente scritto in modo errato e deve essere rifatto. Le eccezioni sono, di fatto, eccezioni: una situazione eccezionale e non pianificata che si è verificata durante l'esecuzione del programma. Questi non sono errori gravi come Error, ma richiedono la nostra attenzione. Tutte le eccezioni sono divise in 2 tipi: selezionate ( selezionate ) e non selezionate ( non selezionate ). Tutte le eccezioni controllate provengono da Exception. Cosa significa “verificabile”? Ne abbiamo parlato parzialmente nell'ultima lezione : "...il compilatore Java conosce le eccezioni più comuni e sa in quali situazioni possono verificarsi." Sa, ad esempio, che se un programmatore legge i dati da un file in codice, potrebbe facilmente verificarsi la situazione in cui il file non esiste. E ci sono molte di queste situazioni che può prevedere in anticipo. Pertanto, il compilatore controlla in anticipo il nostro codice per potenziali eccezioni. Se li trova, non compilerà il codice finché non li elaboreremo o non li inoltreremo all'inizio. Il secondo tipo di eccezione è “non controllato”. Vengono dalla classe RuntimeException. In cosa differiscono da quelli testati? Sembrerebbe che ci siano anche un sacco di classi diverse che provengono RuntimeExceptione descrivono eccezioni di runtime specifiche. La differenza è che il compilatore non prevede questi errori. Sembra dire: “Al momento della stesura del codice non ho trovato nulla di sospetto, ma qualcosa è andato storto mentre funzionava. A quanto pare ci sono errori nel codice!” E infatti lo è. Le eccezioni non controllate sono spesso il risultato di errori del programmatore. E il compilatore chiaramente non è in grado di prevedere tutte le possibili situazioni errate che le persone possono creare con le proprie mani :) Pertanto, non controllerà la gestione di tali eccezioni nel nostro codice. Hai già riscontrato diverse eccezioni non verificate:

• ArithmeticExceptionsi verifica quando diviso per zero
• ArrayIndexOutOfBoundsExceptionSi verifica quando si tenta di accedere a una cella esterna all'array.

In teoria, ovviamente, i creatori di Java avrebbero potuto introdurre una gestione obbligatoria di tali eccezioni, ma cosa diventerebbe allora il codice? Con qualsiasi operazione di divisione di numeri, dovresti scrivere un try-catch per verificare se stai dividendo accidentalmente per zero? Ogni volta che accedi a un array, dovresti scrivere un try-catch per verificare se sei andato oltre questi limiti. Qualsiasi codice scritto sarebbe spaghetti e completamente illeggibile. È logico che questa idea sia stata abbandonata. Pertanto, non è necessario che le eccezioni non controllate siano gestite in blocchi try-catch o lanciate all'inizio, sebbene ciò sia tecnicamente possibile, come con Error.

Come lanciare la tua eccezione

Naturalmente, i creatori di Java non sono in grado di provvedere a tutte le situazioni eccezionali che possono verificarsi nei programmi. Ci sono troppi programmi nel mondo e sono troppo diversi. Ma va bene, perché puoi creare le tue eccezioni se necessario. Questo viene fatto molto facilmente. Tutto quello che devi fare è creare la tua classe. Il suo nome deve terminare con “Eccezione”. Il compilatore non ne ha bisogno, ma i programmatori che leggono il tuo codice capiranno immediatamente che si tratta di una classe di eccezione. Inoltre, è necessario indicare che la classe proviene da class Exception. Questo è già necessario per il compilatore e per il corretto funzionamento. Ad esempio, abbiamo una classe Dog - Dog. Possiamo portare a spasso il cane usando il walk(). Ma prima dobbiamo verificare se il nostro animale domestico indossa collare, guinzaglio e museruola. Se manca uno di questi, lanceremo la nostra eccezione DogIsNotReadyException. Il suo codice sarà simile al seguente:

public class DogIsNotReadyException extends Exception {

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

Per indicare che una classe è un’eccezione è necessario scrivere extends Exception dopo il nome della classe: ciò significa che “la classe deriva dalla classe Exception”. Nel costruttore, chiameremo semplicemente il costruttore della classe Exceptioncon una riga message: mostrerà all'utente un messaggio dal sistema che descrive l'errore che si è verificato. Questo è come apparirà 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("Let's go for a walk!");
   if (isCollarPutOn && isLeashPutOn && isMuzzlePutOn) {
       System.out.println("Hurrah, let's go for a walk!" + name + " I am glad!");
   } else {
       throw new DogIsNotReadyException("Dog " + name + "not ready for a walk! Check your gear!");
   }
 }

}

Ora il nostro metodo walk()lancia un'eccezione DogIsNotReadyException. Questo viene fatto utilizzando la parola chiave throw. Come abbiamo detto prima, un'eccezione è un oggetto. Pertanto, nel nostro metodo, quando si verifica una situazione eccezionale - manca qualcosa al cane - creiamo un nuovo oggetto di classe DogIsNotReadyExceptione lo inseriamo nel programma utilizzando la parola throw. walk()Aggiungiamo i tiri alla firma del metodo DogIsNotReadyException. In altre parole, il compilatore è ora consapevole che una chiamata al metodo walk()può generare un'eccezione. Pertanto, quando lo chiamiamo da qualche parte nel programma, sarà necessario gestire l'eccezione. Proviamo a farlo nel metodo main():

public static void main(String[] args) {

   Dog dog = new Dog("Mukhtar");
   dog.putCollar();
   dog.putMuzzle();
   dog.walk();//Unhandled exception: DogIsNotReadyException
}

Non compila, eccezione non gestita! Racchiudiamo il nostro codice in un blocco try-catchper gestire l'eccezione:

public static void main(String[] args) {

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

Ora diamo un'occhiata all'output della console:

Ошейник надет! 
Намордник надет! 
Собираемся на прогулку! 
Собака Мухтар не готова к прогулке! Проверьте экипировку! 
Проверяем снаряжение! Ошейник надет? true
Поводок надет? false 
Намордник надет? true

Guarda quanto più informativo è diventato l'output della console! Vediamo ogni passaggio avvenuto nel programma; Vediamo dove si è verificato l'errore e notiamo immediatamente cosa manca esattamente al nostro cane :) In questo modo creiamo le nostre eccezioni. Come puoi vedere, niente di complicato. E sebbene gli sviluppatori Java non si siano preoccupati di aggiungere un'eccezione speciale al loro linguaggio per i cani equipaggiati in modo errato, abbiamo corretto la loro svista :)