Differenze tra eccezione ed errore

Sto cercando di saperne di più su Java di base e sui diversi tipi di Throwables, qualcuno può farmi sapere le differenze tra Eccezioni ed Errori?

Gli errori non devono essere colti o gestiti (tranne nel caso più raro). Le eccezioni sono il pane e il burro della gestione delle eccezioni. Il Javadoc spiega bene:

Un errore è una sottoclasse di Throwable che indica gravi problemi che un'applicazione ragionevole non dovrebbe tentare di rilevare. La maggior parte di tali errori sono condizioni anomale.

Guarda alcune delle sottoclassi di Error, prendendo alcuni dei loro commenti JavaDoc:

• AnnotationFormatError - Viene generato quando il parser di annotazioni tenta di leggere un'annotazione da un file di classe e determina che l'annotazione non è corretta.
• AssertionError - Generato per indicare che un'asserzione non è riuscita.
• LinkageError- Le sottoclassi di LinkageError indicano che una classe ha una certa dipendenza da un'altra classe; tuttavia, quest'ultima classe è stata modificata in modo incompatibile dopo la compilazione della classe precedente.
• VirtualMachineError - Generato per indicare che Java Virtual Machine è rotto o ha esaurito le risorse necessarie per continuare a funzionare.

Esistono davvero tre importanti sottocategorie di Throwable:

• Error - Qualcosa di abbastanza grave è andato storto e la maggior parte delle applicazioni dovrebbe andare in crash anziché tentare di gestire il problema,
• Eccezione non selezionata (aka RuntimeException) - Molto spesso un errore di programmazione come un NullPointerExceptionargomento illegale. Le applicazioni a volte possono gestire o ripristinare da questa Throwablecategoria - o almeno catturarlo con il run()metodo della discussione , registrare il reclamo e continuare a correre.
• Eccezione controllata (alias Tutto il resto) - Le applicazioni dovrebbero essere in grado di catturare e fare in modo significativo qualcosa con il resto, come FileNotFoundExceptione TimeoutException...

Questa diapositiva che mostra la gerarchia eccezione di Java da @ Georgios-gousios spiega in modo conciso le differenze tra Errori ed eccezioni in Java.

Gli errori tendono a segnalare la fine della tua applicazione come la conosci. In genere non può essere recuperato e dovrebbe causare la chiusura della VM. Catturarli non dovrebbe essere fatto se non per registrare o visualizzare il messaggio appropriato prima di uscire.

Esempio: OutOfMemoryError - Non puoi fare molto perché il tuo programma non può più essere eseguito.

Le eccezioni sono spesso recuperabili e, anche se non lo sono, generalmente significano che un'operazione tentata non è riuscita, ma il programma può continuare.

Esempio: IllegalArgumentException - Passato dati non validi a un metodo in modo che la chiamata al metodo non sia riuscita, ma non influisce sulle operazioni future.

Questi sono esempi semplicistici e c'è un'altra ricchezza di informazioni sulle sole eccezioni.

Errori -

1. Errors in java sono di tipo java.lang.Error.
2. Tutti gli errori in Java sono di tipo non selezionato.
3. Errors succede in fase di esecuzione. Non saranno noti al compilatore.
4. È impossibile recuperare dagli errori.
5. Errors sono principalmente causati dall'ambiente in cui l'applicazione è in esecuzione.
6. Esempi: java.lang.StackOverflowError ,java.lang.OutOfMemoryError

Eccezioni -

1. Exceptions in java sono di tipo java.lang.Exception.
2. Exceptioninclude sia il tipo selezionato che quello non selezionato.
3. Le eccezioni selezionate sono note al compilatore, mentre come eccezioni non selezionate non sono note al compilatore perché si verificano in fase di esecuzione.
4. È possibile recuperare da eccezioni gestendole attraverso try-catchblocchi.
5. Exceptions sono principalmente causati dall'applicazione stessa.
6. Esempi: eccezioni controllate: SQLException, IOException
   eccezioni unchecked: ArrayIndexOutOfBoundException, ClassCastException,NullPointerException

ulteriori letture: http://javaconceptoftheday.com/difference-between-error-vs-exception-in-java/

Sun lo mette al meglio :

Un errore è una sottoclasse di Throwable che indica gravi problemi che un'applicazione ragionevole non dovrebbe tentare di rilevare.

La descrizione della Errorclasse è abbastanza chiara:

Una Errorsottoclasse Throwable indica una serie di problemi che un'applicazione ragionevole non dovrebbe tentare di rilevare. La maggior parte di questi errori sono condizioni anomale. L' ThreadDeath errore, sebbene sia una condizione "normale", è anche una sottoclasse Errorperché la maggior parte delle applicazioni non dovrebbe tentare di rilevarlo.

Non è necessario un metodo per dichiarare nella clausola dei suoi tiri eventuali sottoclassi Errorche potrebbero essere generate durante l'esecuzione del metodo ma non rilevate, poiché questi errori sono condizioni anomale che non dovrebbero mai verificarsi.

Citato dalla stessa documentazioneError Java della classe .

In breve, non dovresti prendere Errors, tranne che hai una buona ragione per farlo. (Ad esempio per impedire che l'implementazione del web server vada in crash se un servlet esaurisce la memoria o qualcosa del genere.)

Una Exception, d'altra parte, è solo un'eccezione normale come in qualsiasi altra lingua moderna. Una descrizione dettagliata è disponibile nella documentazione dell'API Java o in qualsiasi risorsa online o offline.

Esistono diverse somiglianze e differenze tra classi java.lang.Exceptione java.lang.Error.

Analogie:

• Primo - entrambe le classi estende java.lang.Throwablee come risultato eredita molti dei metodi che sono comuni da utilizzare quando si tratta di errori come: getMessage, getStackTrace, printStackTracee così via.

• In secondo luogo, in quanto sottoclassi di java.lang.Throwableentrambe ereditano le seguenti proprietà:

  • Il lancio stesso e le sue sottoclassi (incluso java.lang.Error) possono essere dichiarati nell'elenco delle eccezioni del metodo utilizzando la throwsparola chiave. Tale dichiarazione richiesta solo per java.lang.Exceptione sottoclassi, per java.lang.Throwable, java.lang.Errore java.lang.RuntimeExceptioned i loro sottoclassi è facoltativo.

  • Solo java.lang.Throwablee sottoclassi possono essere utilizzate nella catchclausola.

  • Solo java.lang.Throwablee le sottoclassi possono essere utilizzate con la parola chiave - throw.

La conclusione di questa proprietà sta seguendo entrambe java.lang.Errore java.lang.Exceptionpuò essere dichiarata nell'intestazione del metodo, può essere nella catchclausola, può essere utilizzata con la parola chiave throw.

differenze:

• Primo: differenza concettuale: java.lang.Errorprogettata per essere lanciata dalla JVM e indicare seri problemi e destinata a fermare l'esecuzione del programma invece di essere scoperta (ma è possibile come per qualsiasi altro java.lang.Throwablesuccessore).

  Un passaggio dalla descrizione di Javadoc su java.lang.Error:

  ... indica gravi problemi che un'applicazione ragionevole non dovrebbe tentare di rilevare.

  Al contrario, java.lang.Exceptionprogettato per rappresentare gli errori previsti e che possono essere gestiti da un programmatore senza interrompere l'esecuzione del programma.

  Un passaggio dalla descrizione di Javadoc su java.lang.Exception:

  ... indica le condizioni che un'applicazione ragionevole potrebbe voler catturare.

• La seconda differenza tra java.lang.Errore java.lang.Exceptionquella prima considerata un'eccezione non selezionata per il controllo delle eccezioni in fase di compilazione. Poiché il lancio del codice risultante java.lang.Erroro le sue sottoclassi non richiedono di dichiarare questo errore nell'intestazione del metodo. Mentre si lancia la java.lang.Exceptiondichiarazione richiesta nell'intestazione del metodo.

Gettabile e diagramma delle classi successive (proprietà e metodi omessi).

L'IMO è un errore che può causare il fallimento dell'applicazione e non deve essere gestito. Un'eccezione è qualcosa che può causare risultati imprevedibili, ma da cui è possibile recuperare.

Esempio:

Se un programma ha esaurito la memoria, si tratta di un errore poiché l'applicazione non può continuare. Tuttavia, se un programma accetta un tipo di input errato, è un'eccezione poiché il programma può gestirlo e reindirizzare per ricevere il tipo di input corretto.

Gli errori sono principalmente causati dall'ambiente in cui l'applicazione è in esecuzione. Ad esempio, OutOfMemoryError si verifica quando JVM esaurisce la memoria o StackOverflowError si verifica quando lo stack trabocca.

Le eccezioni sono principalmente causate dall'applicazione stessa. Ad esempio, NullPointerException si verifica quando un'applicazione tenta di accedere a un oggetto null o ClassCastException si verifica quando un'applicazione tenta di trasmettere tipi di classe incompatibili.

Fonte: differenza tra errore e eccezione in Java

Ecco un riassunto abbastanza buono dell'API Java che rappresenta un errore e un'eccezione:

Un errore è una sottoclasse di Throwable che indica gravi problemi che un'applicazione ragionevole non dovrebbe tentare di rilevare. La maggior parte di tali errori sono condizioni anomale. L'errore ThreadDeath, sebbene una condizione "normale", è anche una sottoclasse di Error poiché la maggior parte delle applicazioni non dovrebbe tentare di rilevarlo.

Non è necessario un metodo per dichiarare nella clausola dei suoi tiri eventuali sottoclassi di errore che potrebbero essere generate durante l'esecuzione del metodo ma non rilevate, poiché questi errori sono condizioni anomale che non dovrebbero mai verificarsi.

OTOH, per Eccezioni, l'API Java dice:

La classe Exception e le sue sottoclassi sono una forma di Lanciabile che indica le condizioni che un'applicazione ragionevole potrebbe voler catturare.

Gli errori sono causati dall'ambiente in cui viene eseguita l'applicazione o il programma. La maggior parte delle volte, non è possibile ripristinare da esso in quanto ciò termina l'applicazione o il programma. Javadoc ha avvertito che non dovresti preoccuparti di rilevare tali errori poiché l'ambiente, ad esempio JVM, su tali errori si chiuderà comunque.

Esempi: VirtualMachineError- Generato per indicare che Java Virtual Machine è danneggiata o ha esaurito le risorse necessarie per continuare a funzionare. OutOfMemoryErrorsi verifica quando JVM esaurisce la memoria o si StackOverflowErrorverifica quando lo stack si esaurisce.

Le eccezioni sono causate dall'applicazione o dal programma stesso; forse a causa del tuo errore. La maggior parte delle volte è possibile ripristinare da esso e l'applicazione continuerà comunque a essere eseguita. Si consiglia di rilevare tali errori per impedire la chiusura anomala dell'applicazione o del programma e / o di essere in grado di personalizzare il messaggio di eccezione in modo che gli utenti visualizzino un messaggio ben formattato anziché i brutti messaggi di eccezione predefiniti sparsi ovunque.

Esempi: si NullPointerExceptionverifica quando un'applicazione tenta di accedere all'oggetto null. o Tentare di accedere a un array con un indice inesistente o chiamare una funzione con dati o parametri errati.