Gestione delle eccezioni: throw, throw e Throwable

Question

Qualcuno di voi può spiegare quali sono le differenze tra throw, throws e Throwable e quando utilizzare quale?

Answer 1

• throws: Utilizzato durante la scrittura di metodi, di dichiarare che il metodo in questione getta la (controllato) eccezione specificata.

  Diversamente dalle eccezioni controllate, le eccezioni di runtime (NullPointerExceptions ecc.) Possono essere generate senza che il metodo dichiari throws NullPointerException.

• throw: Istruzioni per l'effettiva eccezione. (O più nello specifico, il Throwable).

  La parola chiave throw è seguita da un riferimento a Throwable (di solito un'eccezione).

Esempio:

---

• Throwable: una classe che è necessario estendere al fine di creare il proprio, personalizzato, throwable.

Esempio:

---

• Official exception-tutorial

Answer 2

Throw viene utilizzato per lanciare un'eccezione, throws (se ho indovinato correttamente) è usato per indicare che il metodo può buttare particolari eccezioni, e la classe Throwable è la superclasse di tutti gli errori e le eccezioni in Java

How to Throw Exceptions

Answer 3

tiro - E 'usato per lanciare una dichiarazione Exception.The tiro richiede un unico argomento: un oggetto di classe Throwable

tiri - Questo è usato per specifica che il metodo può lanciare un'eccezione

Throwable - Questa è la superclasse di tutti gli errori e le eccezioni nel linguaggio Java. puoi lanciare solo oggetti che derivano dalla classe Throwable. throwable contiene un'istantanea della stack di esecuzione della sua discussione nel momento in cui è stato creato

Answer 4

• throw: dichiarazione di gettare oggetto t dove t instanceof java.lang.Throwable deve essere vero.
• throws: un token di firma del metodo per specificare le eccezioni verificate throw n con tale metodo.
• java.lang.Throwable: il tipo principale di tutti gli oggetti che possono essere lanciati (e catturati).

See here for a tutorial on using exceptions.

Answer 5

Questo veramente facile da capire.

Il java.lang.Throwable:

La classe Throwable è la superclasse di tutti gli errori e eccezioni nel linguaggio Java. Solo oggetti che sono istanze di questa classe (o una delle sue sottoclassi) sono generata dalla Java Virtual Machine o possono essere gettati dalla dichiarazione Java throw. Analogamente, solo questa classe o una delle sottoclassi può essere l'argomento digitare in una clausola catch. More

La parola chiave tiri è utilizzato in dichiarazione di metodo, questo specificare il tipo di eccezione [classe Throwable] ci può aspettare da questo metodo.

La parola chiave throw viene utilizzata per lanciare un oggetto che è un'istanza di classe Throwable.

---

Lest vedere qualche esempio:

Creiamo noi stessi una classe di eccezione

public class MyException super Exception { 

} 

Il creiamo un metodo che creare un oggetto dalla nostra classe di eccezione e getta usando la parola chiave lancio.

private void throwMeAException() throws MyException //We inform that this method throws an exception of MyException class 
{ 
    Exception e = new MyException(); //We create an exception 

    if(true) { 
    throw e; //We throw an exception 
    } 
} 

Quando ci accingiamo a utilizzare il metodo throwMeAException(), siamo costretti a prendersi cura di esso in modo specifico perché abbiamo le informazioni che getta qualcosa, in questo caso abbiamo tre opzioni.

prima opzione è utilizzare blocco try e catch per gestire l'eccezione:

private void catchException() { 

    try { 
    throwMeAException(); 
    } 
    catch(MyException e) { 
    // Here we can serve only those exception that are instance of MyException 
    } 
} 

Seconda opzione è quella di passare l'eccezione

private void passException() throws MyException { 

     throwMeAException(); // we call the method but as we throws same exception we don't need try catch block. 

    } 

opzioni terzo è quello di catturare e ri-generare l'eccezione

private void catchException() throws Exception { 

    try { 
    throwMeAException(); 
    } 
    catch(Exception e) { 
     throw e; 
    } 
} 

---

Riattivare, quando è necessario interrompere un'azione, è possibile lanciare l'eccezione che verrà ripristinata fino a quando non viene eseguita da un blocco try-catch. Ovunque tu usi il metodo che genera un'eccezione, dovresti gestirlo con il blocco try-catch o aggiungere le dichiarazioni ai tuoi metodi.

L'eccezione di questa regola è java.lang.RuntimeException quelli che non devono essere dichiarati. Questa è un'altra storia come l'aspetto dell'uso delle eccezioni.

Answer 6

proiezione:

è usato per lanciare in realtà l'eccezione, mentre getta è dichiarativa per il metodo. Non sono intercambiabili.

throw new MyException("Exception!); 

Produce:

Questo è da utilizzare quando non si utilizza l'istruzione catch try nel codice, ma si sa che questa classe particolare, è in grado di gettare così e così eccezione (controllata solo eccezioni). In questo non usi try catch block ma scrivi usando la clausola throw al punto appropriato del tuo codice e l'eccezione viene lanciata al chiamante del metodo e viene gestita da esso. Anche la parola chiave throws viene utilizzata quando la funzione può lanciare un'eccezione controllata.

public void myMethod(int param) throws MyException 

Answer 7

Stessa risposta come sopra ma con copia-incolla piacere:

public class GsonBuilderHelper { 
    // THROWS: method throws the specified (checked) exception 
    public static Object registerAndRun(String json) throws Exception { 

     // registering of the NaturalDeserializer 
     GsonBuilder gsonBuilder = new GsonBuilder(); 
     gsonBuilder.registerTypeAdapter(Object.class, new NaturalDeserializer()); 
     Gson gson = gsonBuilder.create(); 

     Object natural = null; 
     try { 
      // calling the NaturalDeserializer 
      natural = gson.fromJson(json, Object.class); 
     } catch (Exception e) { 
      // json formatting exception mainly 
      Log.d("GsonBuilderHelper", "registerAndRun(json) error: " + e.toString()); 
      throw new Exception(e); // <---- THROW: instance of class Throwable. 
     } 
     return natural; 
    } 
} 

Answer 8

Throwable : in Java, tutte le classi di execption di errore e sono drieved dalla classe java.lang.Throwable. È la parte superiore della gerarchia delle classi di errori ed eccezioni. Solo gli oggetti che sono istanze di questa classe (o una delle sue sottoclassi) vengono lanciati dalla Java Virtual Machine o possono essere lanciati dall'istruzione throw di Java.

Throws: è un modificatore post-metodo e specifica quali espressioni possono essere generate dal metodo. Se sono controllate le eccezioni, il compilatore garantirà che il codice che invoca quel metodo deve catturare queste eccezioni controllate.

Throw: istruzione viene utilizzata per generare un errore o eccezioni. l'istruzione throw richiede un singolo argomento: un'istanza di qualsiasi sottoclasse della classe Throwable o della classe Throwable. L'esecuzione dell'istruzione throw attiva la JVM per generare questa eccezione e provoca un'eccezione.

Answer 9

Listing few ...

tiro

1. Java throw parola chiave è usato per esplicitamente throw un'eccezione.
2. L'eccezione verificata non può essere propagata utilizzando solo throw.
3. Throw è seguito da un'istanza.
4. Throw viene utilizzato all'interno del metodo.
5. Non è possibile throw più eccezioni.

Lanci

1. Java throws parola chiave viene utilizzata per dichiarare un'eccezione.
2. L'eccezione verificata può essere propagata con throws.
3. Throws è seguito dalla classe.
4. Throws viene utilizzato con la firma del metodo.
5. È possibile dichiarare più eccezioni ad es. public void method()throws IOException,SQLException

Answer 10

Ci sono 2 tipi principali di eccezioni:
eccezioni di runtime (non controllati): ad es. NullPointerException, ClassCastException, ..
Eccezioni controllate: es. FileNotFoundException, CloneNotSupportedException, ..

Le eccezioni di runtime sono eccezioni che si verificano in fase di esecuzione e lo sviluppatore non deve cercare di catturarlo o fermarlo. Si scrive solo il codice per evitarli o si invia un comando di lancio, quando viene soddisfatto il criterio di errore. Usiamo il tiro all'interno del corpo del metodo.

public Rational(int num, int denom){ 
if(denom <= 0) { 
    throw new IllegalArgumentException("Denominator must be positive"); 
} 
this.num=num; 
this.denom=denom; 
} 

Tuttavia, per eccezioni controllate, la JVM si aspetta di gestire e darà errore di compilazione, se non gestita in modo si dichiara che getta che tipo di eccezione come si vede di seguito nel metodo clone().

Class Employee{ 
public Employee clone() throws CloneNotSupportedException{ 
    Employee copy = (Employee)super.clone(); 
    copy.hireDate = (Date)hireDate.clone(); 
    return copy; 
} 
} 

Answer 11

1. throw keyword used to throw user defined exceptions.(we can throw predefined exception too). 
2. Using throws keyword we can explicitly provide the information about unhand-led exceptions of the method to the end user, Java compiler, JVM. 

tiro vs getta

http://www.instanceofjava.com/2016/04/exception-handling-interview-questions.html