Come gestire le eccezioni Java nel modo giusto

Come programmatore principiante Come imparare Programmazione senza tutti gli stress Come imparare Programmazione senza tutti gli stress Forse hai deciso di perseguire la programmazione, sia per una carriera o solo come un hobby. Grande! Ma forse stai iniziando a sentirti sopraffatto. Non così eccezionale. Ecco l'aiuto per facilitare il tuo viaggio. Per saperne di più, il concetto di la gestione delle eccezioni può essere difficile da avvolgere la testa. Non che il concetto stesso sia difficile, ma la terminologia può far sembrare più avanzato di quanto non sia. Ed è una caratteristica così potente che è soggetta a abusi e abusi.

In questo articolo imparerai quali sono le eccezioni, perché sono importanti, come usarle e gli errori più comuni da evitare. La maggior parte delle lingue moderne 6 Lingue di programmazione più semplici da apprendere per principianti 6 Linguaggi di programmazione più semplici da imparare per principianti Imparare a programmare significa trovare la lingua giusta tanto quanto il processo di edificazione. Ecco i primi sei linguaggi di programmazione più facili per i principianti. Ulteriori informazioni hanno un qualche tipo di gestione delle eccezioni, quindi se si passa da Java 7 Trucchi utili per padroneggiare un nuovo linguaggio di programmazione 7 Trucchi utili per padroneggiare un nuovo linguaggio di programmazione Va bene essere sopraffatti quando si sta imparando a programmare. Probabilmente dimenticherai le cose così velocemente come le impari. Questi suggerimenti possono aiutarti a conservare meglio tutte le nuove informazioni. Per saperne di più, puoi prendere la maggior parte di questi suggerimenti con te.

Comprendere le eccezioni Java

In Java, a eccezione è un oggetto che indica qualcosa di anormale (o “eccezionale”) si è verificato durante l'esecuzione della tua applicazione. Tali eccezioni sono gettato, che in pratica significa che viene creato un oggetto di eccezione (simile a come sono gli errori) “sollevato”).

La bellezza è che puoi catturare eccezioni generate, che ti consentono di gestire le condizioni anomale e consentire alla tua applicazione di continuare a funzionare come se nulla fosse andato storto. Ad esempio, mentre un puntatore nullo in C potrebbe mandare in crash l'applicazione, Java ti permette di lanciare e catturare NullPointerExceptions prima che una variabile nulla abbia la possibilità di causare un arresto anomalo.

Ricorda, un'eccezione è solo un oggetto, ma con una caratteristica importante: deve essere estesa dal Eccezione classe o qualsiasi sottoclasse di Eccezione. Mentre Java ha tutti i tipi di eccezioni built-in, puoi anche crearne uno tuo se lo desideri. Alcune delle più comuni eccezioni Java includono:

• NullPointerException
• NumberFormatException
• IllegalArgumentException
• RuntimeException
• IllegalStateException

Quindi cosa succede quando lanci un'eccezione?

Innanzitutto, Java esamina il metodo immediato per vedere se esiste un codice che gestisce il tipo di eccezione che hai lanciato. Se un gestore non esiste, esamina il metodo che ha chiamato il metodo corrente per verificare se esiste un handle. Altrimenti, guarda al metodo che ha chiamato quello metodo, quindi il metodo successivo, ecc. Se l'eccezione non viene rilevata, l'applicazione stampa una traccia dello stack e quindi si blocca. (In realtà è più sfumato del semplice arresto anomalo, ma si tratta di un argomento avanzato che va oltre lo scopo di questo articolo.)

UN traccia dello stack è un elenco di tutti i metodi che Java ha attraversato durante la ricerca di un gestore di eccezioni. Ecco come appare una traccia stack:

Eccezione nella discussione "main" java.lang.NullPointerException su com.example.myproject.Book.getTitle (Book.java:16) su com.example.myproject.Author.getBookTitles (Author.java:25) su com.example. myproject.Bootstrap.main (Bootstrap.java:14)

Possiamo ricavare molto da questo. Innanzitutto, l'eccezione generata era a NullPointerException. Si è verificato nel getTitle () metodo sulla riga 16 di Book.java. Da quel metodo è stato chiamato getBookTitles () sulla linea 25 di Author.java. Quello il metodo è stato chiamato da principale() sulla riga 14 di Bootstrap.java. Come puoi vedere, sapere tutto questo rende più facile il debug.

Ma ancora, il vero vantaggio delle eccezioni è che puoi “maniglia” la condizione anomala rilevando l'eccezione, impostando le cose correttamente e riprendendo l'applicazione senza arrestarsi.

Utilizzo delle eccezioni Java nel codice

Diciamo che hai someMethod () che prende un numero intero ed esegue una logica che potrebbe interrompersi se il numero intero è minore di 0 o maggiore di 100. Potrebbe essere un buon posto per generare un'eccezione:

public void someMethod (int value) if (valore < 0 || value > 100) lancia nuova IllegalArgumentException();  // ...

Per cogliere questa eccezione, devi andare dove someMethod () viene chiamato e usa il blocco try-catch:

public void callingMethod () try someMethod (200); someOtherMethod ();  catch (IllegalArgumentException e) // gestisce l'eccezione qui // ...

Tutto all'interno del provare il blocco verrà eseguito nell'ordine finché non viene generata un'eccezione. Non appena viene generata un'eccezione, tutte le istruzioni successive vengono saltate e la logica dell'applicazione salta immediatamente a catturare bloccare.

Nel nostro esempio, inseriamo il blocco try e chiamiamo immediatamente someMethod (). Poiché 200 non è compreso tra 0 e 100, a IllegalArgumentException viene lanciato Questo termina immediatamente l'esecuzione di someMethod (), salta il resto della logica nel blocco try (someOtherMethod () non viene mai chiamato) e riprende l'esecuzione all'interno del blocco catch.

Cosa succederebbe se chiamassimo someMethod (50) anziché? Il IllegalArgumentException non verrebbe mai gettato. someMethod () si eseguirebbe normalmente. Il blocco try verrebbe eseguito normalmente, chiamando someOtherMethod () quando someMethod () completa. quando someOtherMethod () termina, il blocco catch verrà saltato e callingMethod () continuerebbe.

Nota che puoi avere più blocchi catch per ogni blocco try:

public void callingMethod () try someMethod (200); someOtherMethod ();  catch (IllegalArgumentException e) // gestisce l'eccezione in qui catch (NullPointerException e) // gestisce l'eccezione in qui // ...

Si noti inoltre che un opzionale finalmente esiste anche un blocco:

metodo public void () try // ... catch (Exception e) // ... finally // ...

Il codice all'interno di un blocco finally è sempre eseguito indipendentemente da cosa. Se si dispone di un'istruzione return nel blocco try, il blocco finally viene eseguito prima di uscire dal metodo. Se si lancia un'altra eccezione nel blocco catch, il blocco finally viene eseguito prima che venga generata l'eccezione.

Dovresti usare il blocco finally quando hai degli oggetti che devono essere ripuliti prima che il metodo finisca. Ad esempio, se hai aperto un file nel blocco try e successivamente hai generato un'eccezione, il blocco finally ti consente di chiudere il file prima di abbandonare il metodo.

Nota che puoi avere un blocco finale senza blocco catch:

metodo public void () try // ... finally // ...

Ciò ti consente di eseguire qualsiasi operazione di pulizia necessaria consentendo nel contempo alle eccezioni generate di propagare lo stack di invocazione del metodo (ad esempio, non si desidera gestire l'eccezione in questo caso, ma è necessario prima ripulire).

Controllato vs Eccezioni non verificate in Java

A differenza della maggior parte delle lingue, Java distingue tra controllate le eccezioni e eccezioni non controllate (ad esempio, C # ha solo eccezioni non controllate). Un'eccezione controllata dovere essere catturati nel metodo in cui viene generata l'eccezione altrimenti il ​​codice non verrà compilato.

Per creare un'eccezione controllata, estendere da Eccezione. Per creare un'eccezione non controllata, estendi da RuntimeException.

Qualsiasi metodo che genera un'eccezione controllata deve denotare questo nella firma del metodo usando getta parola chiave. Dal momento che il built-in di Java IOException è un'eccezione controllata, il seguente codice non verrà compilato:

public void wontCompile () // ... if (someCondition) throw new IOException ();  // ...

Devi prima dichiarare che genera un'eccezione controllata:

public void willCompile () genera IOException // ... if (someCondition) throw new IOException ();  // ...

Si noti che un metodo può essere dichiarato come un lancio di un'eccezione, ma mai effettivamente lanciare un'eccezione. Anche così, l'eccezione dovrà comunque essere catturata altrimenti il ​​codice non verrà compilato.

Quando dovresti usare le eccezioni controllate o deselezionate?

La documentazione ufficiale di Java ha una pagina su questa domanda. Riassume la differenza con una succinta regola empirica: “Se un cliente può ragionevolmente aspettarsi di recuperare da un'eccezione, renderlo un'eccezione controllata. Se un client non può eseguire operazioni di ripristino dall'eccezione, renderlo un'eccezione non controllata.”

Ma questa linea guida potrebbe essere obsoleta. Da un lato, le eccezioni controllate danno come risultato un codice più robusto 10 Suggerimenti per scrivere Cleaner & Better Codice 10 Suggerimenti per scrivere Cleaner e Better Code Scrittura di codice pulito sembra più facile di quanto non sia in realtà, ma ne valgono i benefici. Ecco come iniziare a scrivere codice più pulito oggi. Leggi di più . D'altra parte, nessun'altra lingua ha verificato le eccezioni allo stesso modo di Java, il che mostra due cose: una, la funzione non è abbastanza utile per altre lingue per rubarla, e due, si può assolutamente vivere senza di esse. Inoltre, le eccezioni controllate non funzionano bene con espressioni lambda introdotte in Java 8.

Linee guida per l'utilizzo delle eccezioni Java

Le eccezioni sono utili ma facilmente abusate e abusate. Ecco alcuni suggerimenti e best practice per aiutarti a evitare di rovinarli.

• Preferisci eccezioni specifiche alle eccezioni generali. Uso NumberFormatException al di sopra di IllegalArgumentException quando possibile, altrimenti usare IllegalArgumentException al di sopra di RuntimeException quando possibile.
• Non prendere mai Throwable! Il Eccezione la classe in realtà si estende Throwable, e il blocco catch funziona davvero con Throwable o qualsiasi classe che estende Throwable. comunque, il Errore la classe si estende anche Throwable, e tu non vuoi mai catturare un Errore perché Errores indicano seri problemi irrecuperabili.
• Non prendere mai Eccezione! InterruptedException si estende Eccezione, quindi qualsiasi blocco che cattura Eccezione prenderà anche InterruptedException, e questa è un'eccezione molto importante a cui non vuoi fare confusione (specialmente nelle applicazioni multi-thread) a meno che tu non sappia cosa stai facendo. Se non sai quale eccezione prendere, considera di non prendere nulla.
• Usa messaggi descrittivi per facilitare il debug. Quando si genera un'eccezione, è possibile fornire a Stringa messaggio come argomento. È possibile accedere a questo messaggio nel blocco catch tramite il comando Exception.getMessage () metodo, ma se l'eccezione non viene mai rilevata, il messaggio verrà visualizzato anche come parte della traccia dello stack.
• Cerca di non catturare e ignorare le eccezioni. Per aggirare l'inconveniente delle eccezioni controllate, molti programmatori novizi e pigri configureranno un blocco catch ma lo lasceranno vuoto. Male! Gestiscilo sempre con garbo, ma se non puoi, stampa almeno una traccia dello stack in modo da sapere che l'eccezione è stata lanciata. Puoi farlo usando il Exception.printStackTrace () metodo.
• Attenzione all'eccesso di eccezioni. Quando hai un martello, tutto sembra un chiodo. Quando impari per la prima volta sulle eccezioni, potresti sentirti obbligato a trasformare tutto in un'eccezione ... fino al punto in cui la maggior parte del flusso di controllo dell'applicazione si riduce alla gestione delle eccezioni. Ricorda, le eccezioni sono pensate per “eccezionale” occorrenze!

Ora dovresti essere abbastanza comodo con le eccezioni per capire cosa sono, perché vengono utilizzati e come incorporarli nel tuo codice. Se non comprendi completamente il concetto, va bene! Mi ci è voluto un po 'per farlo “clic” nella mia testa, quindi non sento di aver bisogno di precipitarlo 6 Segni che non sei destinato a essere un programmatore 6 Segni che non sei destinato a essere un programmatore Non tutti sono tagliati per essere un programmatore. Se non sei completamente sicuro di essere un programmatore, ecco alcuni segnali che potrebbero indirizzarti nella giusta direzione. Leggi di più . Prenditi il ​​tuo tempo.

Hai qualche domanda? Conoscere eventuali altri suggerimenti relativi alle eccezioni che ho perso? Condividili nei commenti qui sotto!

Scopri di più su: Java.