Differenze tra Runtime / Selezionato / Deselezionato / Errore / Eccezione

Quali sono le eccezioni del runtime e quali sono le eccezioni controllate / non verificate e la differenza tra errori / eccezioni. Perché questi molti tipi? Piuttosto, Java può semplicemente seguire un semplice progetto (basta provare / catturare tutti i tipi) per gestire una condizione anormale in un programma?

Throwable è in cima a tutte le eccezioni. Sotto Throwable hai errori ed eccezioni. Sotto Exception hai RuntimeException.

Java ha due tipi di eccezioni: selezionata e deselezionata. Le eccezioni controllate vengono applicate dal compilatore (devi dichiararle nella clausola throws e prenderle alla fine). Le eccezioni non controllate non vengono applicate per la cattura o la dichiarazione nella clausola di tiri.

(Parte controverso della risposta)

Lancio del proiettile in modo che esista un genitore per tutti i tipi di eccezione. Non dovresti mai dichiarare di buttare Throwable e non prenderlo mai (a meno che tu non sappia davvero cosa stai facendo).

Esiste un errore che indica problemi con l’ambiente runtime, cose che il programma probabilmente non è in grado di ripristinare, come un file di class formattato male o la VM che sta esaurendo la memoria. Non dovresti prendere un errore se non sai veramente cosa stai facendo.

L’eccezione esiste come root per tutti gli errori non programmatori (vedere RuntimeException per l’eccezione a questo), ad esempio non è ansible creare un file perché il disco è pieno. Non dovresti lanciare, lanciare o catturare l’eccezione. Se devi catturare l’eccezione assicurati di sapere cosa stai facendo.

RuntimeException esiste per indicare tutti gli errori del programmatore, come andare oltre la fine di un array o chiamare un metodo su un object nullo. Queste sono cose che dovresti correggere in modo che non generino eccezioni: indicano che tu, il programmatore, hai rovinato il codice. Ancora una volta, non dovresti prenderli a meno che tu non sappia cosa stai facendo.

Dato che sono un nuovo sviluppatore Java, ho anche incontrato alcune difficoltà nel distinguere e gestire diversi tipi di eccezioni. Questo è il motivo per cui ho fatto una breve nota su questo argomento, e ogni volta che mi confondo lo passo attraverso. Eccolo con l’immagine della gerarchia di classi Throwable :
Gerarchia di classi lanciabili

[immagine per gentile concessione di JavaTpoint ].

Ci sono tre classi chiave da ricordare qui: Throwable , Exception ed Error . Tra queste classi, l’ Exception può essere suddivisa in due tipi: “Eccezione controllata” e “Eccezione non verificata”.

Eccezione controllata:

  • Queste sono le classi che estendono Throwable tranne RuntimeException ed Error .
  • Sono anche conosciuti come eccezioni del tempo di compilazione perché vengono controllati in fase di compilazione, il che significa che il compilatore ci costringe a gestirli con try/catch o indicare nella firma della funzione che li throws e costringendoci a gestirli nel chiamante.
  • Si tratta di problemi risolvibili a livello di codice causati da condizioni impreviste al di fuori del controllo del codice (ad esempio database inattivo, errore I / O file, input errato, ecc.).
  • Esempio: IOException , SQLException , ecc.

Eccezione non selezionata:

  • Le classi che estendono RuntimeException sono note come eccezioni non controllate.
  • Le eccezioni non controllate non vengono controllate in fase di compilazione, ma piuttosto in fase di runtime, da cui il nome.
  • Sono anche problemi risolvibili a livello di codice, ma a differenza dell’eccezione verificata sono causati da errori nel stream di codice o nella configurazione.
  • Esempio: ArithmeticException , NullPointerException , ArrayIndexOutOfBoundsException , ecc.
  • Dal momento che sono errori di programmazione, possono essere evitati con una codifica piacevolmente / saggia. Ad esempio “dividendo per zero” produce una ArithmeticException , che può essere evitata con un semplice controllo sul divisore. Allo stesso modo possiamo evitare NullPointerException semplicemente controllando i riferimenti: if (object != null) o usando anche tecniche migliori .

Errore:

  • Error riferisce a una situazione irrecuperabile che non viene gestita da un try/catch .
  • Esempio: OutOfMemoryError , VirtualMachineError , AssertionError , ecc.

Perché questo molti tipi?

Oltre alla risposta di Stephen C , voglio dire: la gestione delle eccezioni è un’operazione relativamente costosa in Java. Non dovremmo mettere tutte le situazioni eccezionali in un blocco try/catch . L’uso eccessivo di try/catch può ostacolare le prestazioni del programma.

Alla fine, le Exception dovrebbero essere gestite al livello di programmazione ogni volta che è ansible. D’altra parte, non possiamo gestire Error s, quindi questi potrebbero essere alcuni motivi logici per cui esistono molti tipi di eccezioni.

La risposta di TofuBeer spiega chiaramente cosa significano le classi di eccezioni.

Perché questi molti tipi? Piuttosto, Java può semplicemente seguire un semplice progetto (basta provare / catturare tutti i tipi) per gestire una condizione anormale in un programma?

Perché? Perché sono necessari! Senza queste 4 classi, gestire le eccezioni per categoria generale sarebbe poco pratico.

  • Come prenderesti “tutti gli errori JVM fatali” senza la class Error ?
  • Come prenderesti “tutte le eccezioni che non sono errori fatali della JVM” senza la class Exception ?
  • Come prenderesti “tutte le eccezioni non controllate” senza la class RuntimeException ?

Le eccezioni del runtime offrono la flessibilità necessaria per evitare la cattura, dichiarando le eccezioni.

  • Errore (generato da VM, non dovrebbe essere catturato o gestito)
    1. Errore VM
    2. Errore di asserzione
    3. Linkage Error … ecc
  • Runtime / Descheck Exception (errore di programmazione, non dovrebbe essere catturato o gestito)
    1. NullPointerException
    2. ArrayIndexOutOfBoundException
    3. IllegalArgumentException … ecc
  • Controlla eccezione (Qualsiasi cosa, le applicazioni dovrebbero essere catturate o gestite)
    1. IOException
    2. FileNotFoundException
    3. SQLException … ecc

Differenza tra eccezioni controllate e non controllate:

Abbiamo molte differenze tra l’eccezione controllata e non controllata, ma tutte le differenze derivano da una considerazione di base che indica se l’ eccezione è risolvibile dal compilatore o meno.

I punti da ricordare sono:

[1] Eccezione controllata significa che il compilatore ha controllato Eccezioni . Significa che il compilatore impone che tale eccezione venga gestita dal blocco try-catch o dalla parola chiave throw.

[2] Le eccezioni non controllate sono quelle per le quali il compilatore non fornisce alcun mandato in quanto possono essere risolti dallo sviluppatore mediante codifica / programmazione in quanto il stream di controllo è controllabile come in ArithmeticException, NullPointerException ArrayIndexOutOfBoundsException, IllegalArgumentException, ecc.

Lo chiamo “Exception-Identity-Test” dove si prende qualsiasi eccezione casuale da java doc e basta fare una domanda. “Hey Eccezione! Puoi essere risolto in modo programmatico? “

Se l’eccezione dice SÌ, si tratta di un’eccezione non verificata in quanto può essere risolta modificando il codice o risolvendo alcuni errori di calcolo, ecc.

D’altra parte se l’Eccezione dice No allora questa è Eccezione Controllata come nel controllo controllato Il controllo Eccezione esce dal nostro codice come se qualcuno modificasse le password del Database o qualcuno scollegasse il cavo di rete, timeout della connessione (ConnectException), alcune risorse non fossero trovate ( FileNotFoundException, ClassNotFound), SQLException, InvocatonTargetException ecc. Questi non possono essere risolti programmando