La gestione delle eccezioni: tiro, tiri e Throwable
-
30-09-2019 - |
Domanda
Qualcuno di voi può spiegare quali siano le differenze tra le throw
, throws
e Throwable
e quando usare quale?
Soluzione
-
throws
:. Utilizzato durante la scrittura di metodi, di dichiarare che il metodo in questione getta specificata (selezionata) eccezioneAl contrario di eccezioni controllate, le eccezioni di runtime (NullPointerExceptions ecc) possono essere gettati senza avere la
throws NullPointerException
metodo di dichiarare. -
throw
: istruzioni effettivamente generare l'eccezione. (O, più precisamente, il Throwable ).La parola chiave tiro è seguita da un riferimento a un
Throwable
(di solito un'eccezione).
Esempio:
-
Throwable
:. Una classe che è necessario estendere al fine di creare il proprio, personalizzato, throwable
Esempio:
Altri suggerimenti
-
throw
:. Dichiarazione di gettaret
oggetto in cuit instanceof java.lang.Throwable
deve essere vero -
throws
:. Una firma di metodo token per specificare eccezioni controllatethrow
n da quel metodo -
java.lang.Throwable
:. Il tipo genitore di tutti gli oggetti che possono essere lanciate (e catturati)
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 questo classe (o una delle sue sottoclassi) sono generata dalla Java Virtual Machine o può essere generata dalla Java dichiarazionethrow
. Analogamente, soltanto questa classe o uno dei sue sottoclassi può essere l'argomento digitare una clausolacatch
. Più
La parola chiave getta ??strong> è usato in dichiarazione di metodo, questo specificare che tipo di eccezione [classe Throwable] ci può aspettare da questo metodo.
La parola chiave due è usato per lanciare un oggetto che è un'istanza della classe Throwable.
Per non vedere alcuni esempi:
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 ??em> usando la parola chiave tiro .
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.
La prima opzione è usare 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
}
}
La 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;
}
}
Ripresa, quando si ha bisogno di fermarsi qualche azione si può generare l'eccezione che andrà indietro fino non è del server da qualche blocco try-catch. Dovunque si utilizza il metodo che genera un'eccezione Si dovrebbe gestire la cosa dal blocco try-catch o aggiungere le dichiarazioni ai vostri metodi.
L'eccezione a questa regola sono java.lang.RuntimeException
quelli non devono essere dichiarati. Questa è un'altra storia come l'aspetto di utilizzo eccezione.
buttare - E 'usato per lanciare una dichiarazione Exception.The tiro richiede un unico argomento: un oggetto di classe Throwable
getta - Questo viene utilizzato per specifica che il metodo può generare un'eccezione
Throwable - Questa è la superclasse di tutti gli errori e le eccezioni in linguaggio Java. si può buttare solo gli oggetti che derivano dalla classe Throwable. throwable contiene un'istantanea della pila esecuzione del filo al momento della sua creazione
Throw
viene utilizzata per generare eccezioni, 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
Lancia:
viene utilizzato per generare l'eccezione in realtà, getta mentre è dichiarativa per il metodo. Essi non sono intercambiabili.
throw new MyException("Exception!);
Produce:
Questa è 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ì eccezioni (eccezioni Solo controllato). In questo non si utilizza try blocco catch, ma in scrittura utilizzando la clausola tiro a punto appropriato nel codice e viene generata l'eccezione al chiamante del metodo e sia gestita da esso. Anche la tiri parola chiave viene utilizzata quando la funzione può lanciare un'eccezione controllata.
public void myMethod(int param) throws MyException
Ci sono 2 tipi principali di eccezioni:
Eccezioni runtime (incontrollato) : ad es. NullPointerException, ClassCastException, ..
eccezioni controllate: ad es. FileNotFoundException, CloneNotSupportedException, ..
Le eccezioni runtime sono eccezioni che si verificano in fase di esecuzione e lo sviluppatore non deve cercare di catturare o fermarlo. È solo il codice di scrittura per evitarli o emettere un comando due , quando i criteri di errore è soddisfatta. Usiamo gettare 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à compilatore errore 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;
}
}
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;
}
}