Quando usare Throwable al posto della nuova eccezione?

Question

Dato: Throwable è la superclasse di Exception.

Quando leggo dei testi quando scrivo le tue "eccezioni", vedo esempi di catch in uso nel blocco new Exception() e altri testi mostrano else in uso nel blocco <=>. Devo ancora vedere una spiegazione di quando si dovrebbe usare ciascuno.

La mia domanda è questa, quando dovrebbe essere usato <=> e quando <=> dovrebbe essere usato?

All'interno del blocco <=> o <=> usando:

throw throwable;

o

throw new Exception();

Answer 1

  

(dai commenti) Il problema che l'ha sollevato è questo   Devo passare un '"eccezione" a   pezzo di codice che un collega sta costruendo   se una raccolta non viene creata.

In tal caso, potresti voler lanciare una eccezione controllata . Potresti lanciare un Exception , un appropriata sottoclasse esistente (tranne RuntimeException e le sue sottoclassi che sono non selezionate ) o una sottoclasse personalizzata di CollectionBuildException (ad es. " <=> "). Consulta il Tutorial Java sulle eccezioni per essere sempre aggiornato con eccezioni Java.

Answer 2

Lancia sempre un Exception (mai un Throwable). In genere non prendi neanche Error, ma puoi farlo. Gettabile è la superclasse di <=> e <=>, quindi cattureresti <=> se non volessi catturare solo <=> s <=> s, questo è il punto. Il fatto è che <=> sono generalmente cose che un'applicazione normale non dovrebbe e non dovrebbe catturare, quindi usa <=> a meno che tu non abbia un motivo specifico per usare <=>.

Answer 3

Non dovresti davvero prendere un'eccezione e lanciarne una nuova come " nuova eccezione " ;.

Invece, se si desidera creare una bolla dell'eccezione, attenersi alla seguente procedura:

try {
    // Do some stuff here
}
catch (DivideByZeroException e) {
    System.out.println("Can't divide by Zero!"); 
} 
catch (IndexOutOfRangeException e) { 
    // catch the exception 
    System.out.println("No matching element found.");
}
catch (Throwable e) {
    throw e; // rethrow the exception/error that occurred
}

Non è una buona pratica, credo, catturare un'eccezione e lanciare una nuova eccezione invece di quella sollevata nel blocco di codice, a meno che non si sollevi un'utile eccezione personalizzata che fornisca un contesto sufficiente per eludere la causa di l'eccezione originale.

Answer 4

Solo due posti dovresti vedere la parola Throwable nel codice:

public static void main(String args[])
{
     try
     {
         // Do some stuff
     }
     catch(Throwable t)
     {

     }
 }

E

public class SomeServlet extends HttpServlet
{
      public void doPost(HttpRequest request, HttpResponse response)
      {
         try
         {
             // Do some stuff
         }
         catch (Throwable t)
         {
              // Log
         }
      }
 }

Answer 5

Throwable è un'interfaccia, non una classe. Due classi estendono Throwable, Exception ed Error.

La regola è: essere il più specifico possibile quando si rilevano le eccezioni, ciò significa ad esempio intercettare Eccezione invece di Lanciabile e IOException invece di Eccezione.

Non rilevare errori: gli errori sono bug. Correggi invece il codice.

Se devi catturare assolutamente tutto, usa " catch Throwable " ;, ma questa è una cattiva forma.

Answer 6

throw new Exception(); è qualcosa che dovresti non mai fare in un blocco catch, ma potresti dover o voler lanciare new SomeException(throwable); (preservando la traccia dello stack completo) invece di throw throwable; in per conformarsi all'API del tuo metodo, ad es quando dichiara di lanciare SomeException ma stai chiamando un codice che potrebbe generare un IOException che non desideri aggiungere alla clausola throws del tuo metodo.

Il caso probabilmente più comune è new RuntimeException(throwable); per evitare di avere una clausola <=> del tutto. Molte persone ti diranno che questo è un abuso orribile perché dovresti usare eccezioni controllate. IMO hanno torto e le eccezioni verificate sono un errore nella progettazione del linguaggio Java che si traduce in un brutto codice non mantenibile.

Answer 7

Come ho sentito quando è uscito java per la prima volta, la teoria era che Throwable potesse essere usato per il trasferimento del controllo in altri casi oltre alle eccezioni. Non l'ho mai visto usato così (e probabilmente è una cosa molto buona).

Quindi, prendi l'eccezione (o meglio ancora, un'eccezione più precisa).

Answer 8

Throwable è pensato per essere catturato solo dal contenitore o dal ciclo principale del programma. La maggior parte delle volte intercetta cose al di sotto di Eccezione, ad es. Errore non aggiunge molte funzionalità a un programma, dopo tutto cosa si può fare se viene generato un errore VirtualError altri errori. Non molto eccetto il log e continua.

Answer 9

Tutte le eccezioni sono un problema alla fine ... anche dire che gli errori sono bug non significa nulla.

Gli errori non sono bug: sono problemi riscontrati dalla macchina virtuale host, ad esempio OutOfMemoryError. Le eccezioni sono un mezzo che l'operazione corrente può utilizzare per notificare che ha fallito e forse fornire una diagnosi.

Answer 10

Generalmente, non lanci o prendi Throwable. In particolare, gli errori JVM (che estendono Error ()) non sono pensati per essere colti dal codice utente a meno che tu non stia facendo uno strano lavoro a livello di sistema.

Treat " Gettabile " come artefatto linguistico. Il & Quot; Eccezione & Quot; class viene chiamato così perché è quello destinato ai programmatori quando vogliono che un blocco di codice esca da " eccezionalmente " - non uscendo normalmente o restituendo un valore.

Ciò include sia le situazioni di errore regolari (per " regolari " intendo al contrario degli errori JVM) sia i luoghi in cui si utilizzano le eccezioni come meccanismo di controllo.

Answer 11

Non dovresti usare Eccezioni come " tipo di ritorno " o ...

Se la condizione che stai lanciando è comune, stai spendendo un'enorme quantità di risorse per restituire quella condizione alla routine chiamante. Le eccezioni sono costose da costruire.

Ho visto casi in cui loop stretti che generavano eccezioni come " negative " per es. Allocazione ID, questa routine ha occupato circa il 99% del tempo della CPU .. quando invece è stata cambiata in una costante di ritorno documentata, questa è scesa al 25%.