Gestion des exceptions: lancer, lancer et lancer

Est-ce que l’un de vous peut expliquer quelles sont les différences entre le throw , le throws et le Throwable ?

  • throws : Utilisé lors de l’écriture de méthodes, pour déclarer que la méthode en question renvoie l’exception spécifiée (cochée).

    Contrairement aux exceptions vérifiées, les exceptions d’exécution (NullPointerExceptions, etc.) peuvent être lancées sans que la méthode declare ne throws NullPointerException .

  • throw : Instruction pour lancer réellement l’exception. (Ou plus précisément, le Throwable ).

    Le mot-clé throw est suivi d’une référence à un Throwable (généralement une exception).

Exemple:

entrer la description de l'image ici


  • Throwable : Une classe que vous devez étendre pour créer votre propre jetable personnalisé.

Exemple:

entrer la description de l'image ici


  • Tutoriel d’exception officiel
  • throw : déclaration pour lancer l’object tt instanceof java.lang.Throwable doit être vrai.
  • throws : un jeton de signature de méthode pour spécifier les exceptions vérifiées throw par cette méthode.
  • java.lang.Throwable : le type parent de tous les objects pouvant être lancés (et interceptés).

Voir ici pour un tutoriel sur l’utilisation des exceptions.

C’est vraiment facile à comprendre.

Le java.lang.Throwable :

La classe Throwable est la super-classe de toutes les erreurs et exceptions du langage Java. Seuls les objects qui sont des instances de cette classe (ou de l’une de ses sous-classes) sont lancés par la machine virtuelle Java ou peuvent être lancés par l’instruction Java throw . De même, seule cette classe ou l’une de ses sous-classes peut être le type d’argument d’une clause catch . Plus

Le mot clé lançant est utilisé dans la déclaration de méthode, cela spécifie le type d’exception [classe Throwable] à laquelle nous pouvons nous attendre de cette méthode.

Le mot clé throw est utilisé pour lancer un object qui est une instance de classe Throwable.


Ne craignez pas de voir un exemple:

Nous créons nous-mêmes une classe d’exception

 public class MyException super Exception { } 

Nous créons une méthode qui crée un object à partir de notre classe d’exception et la lance à l’aide du mot clé.

 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 } } 

Lorsque nous allons utiliser la méthode throwMeAException() , nous sums obligés de nous en occuper de manière spécifique car nous avons les informations qu’elle jette quelque chose, dans ce cas nous avons trois options.

La première option utilise block try et catch pour gérer l’exception:

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

La deuxième option consiste à passer l’exception

  private void passException() throws MyException { throwMeAException(); // we call the method but as we throws same exception we don't need try catch block. } 

La troisième option est d’attraper et de relancer l’exception

 private void catchException() throws Exception { try { throwMeAException(); } catch(Exception e) { throw e; } } 

En reprenant, lorsque vous devez arrêter une action, vous pouvez lancer une exception qui ne sera plus un serveur par un bloc try-catch. Où que vous utilisiez une méthode qui lève une exception Vous devez la gérer par un bloc try-catch ou append les déclarations à vos méthodes.

L’exception de cette règle est java.lang.RuntimeException celles-ci ne doivent pas être déclarées. Ceci est une autre histoire comme l’aspect de l’utilisation des exceptions.

throw – Il est utilisé pour lancer une exception. L’instruction throw nécessite un seul argument: un object de classe pouvant être jeté

Throws – Ceci est utilisé pour spécifier que la méthode peut lancer une exception

Throwable – C’est la super-classe de toutes les erreurs et exceptions du langage Java. vous ne pouvez lancer que des objects dérivés de la classe Throwable. throwable contient un instantané de la stack d’exécution de son thread au moment de sa création

Throw est utilisé pour lancer une exception, throws (si j’ai deviné correctement) est utilisé pour indiquer que la méthode peut lancer une exception particulière, et la classe Throwable est la superclasse de toutes les erreurs et exceptions dans Java

Comment lancer des exceptions

Jeter :

est utilisé pour lancer l’exception, alors que jette est déclarative pour la méthode. Ils ne sont pas interchangeables.

 throw new MyException("Exception!); 

Jette:

Cela doit être utilisé lorsque vous n’utilisez pas l’instruction try catch dans votre code, mais vous savez que cette classe particulière est capable de lancer une telle exception (uniquement les exceptions cochées). Dans ce cas, n’utilisez pas try catch block mais écrivez en utilisant la clause throw au point approprié de votre code et l’exception est renvoyée à l’appelant de la méthode et est gérée par elle. Le mot clé throws est également utilisé lorsque la fonction peut lancer une exception vérifiée.

 public void myMethod(int param) throws MyException 

Throwable : en Java, toutes les classes d’erreur et d’execption sont dérivées de la classe java.lang.Throwable. C’est le sumt de la hiérarchie des classes d’erreur et des exceptions. Seuls les objects qui sont des instances de cette classe (ou de l’une de ses sous-classes) sont lancés par la machine virtuelle Java ou peuvent être lancés par l’instruction Java throw.

Throws: est un modificateur post-méthode et spécifie quelles exécutions peuvent être lancées par la méthode. Si ce sont des exceptions vérifiées, le compilateur garantira que le code invoquant cette méthode doit intercepter ces exceptions vérifiées.

Throw: déclaration est utilisée pour lancer une erreur ou des exceptions. L’instruction throw nécessite un seul argument: une instance de toute sous-classe de la classe Throwable ou Throwable. L’exécution de l’instruction throw déclenche la JVM pour lancer cette exception et provoquer une exception.

Liste quelques …

Jeter

  1. Le mot clé Java throw est utilisé pour throw explicitement une exception.
  2. L’exception vérifiée ne peut pas être propagée à l’aide de throw uniquement.
  3. Throw est suivi d’une instance.
  4. Throw est utilisé dans la méthode.
  5. Vous ne pouvez pas throw plusieurs exceptions.

Jette

  1. Le mot clé Java throws est utilisé pour déclarer une exception.
  2. L’exception vérifiée peut être propagée avec des throws .
  3. Throws sont suivis par la classe.
  4. Throws sont utilisés avec la signature de la méthode.
  5. Vous pouvez déclarer plusieurs exceptions, par exemple, public void method()throws IOException,SQLException une exception public void method()throws IOException,SQLException

Il existe deux types principaux d’exceptions:
Exceptions d’exécution (non vérifiées) : par exemple. NullPointerException, ClassCastException, ..
Exceptions vérifiées: par exemple. FileNotFoundException, CloneNotSupportedException, ..

Les exceptions d’exécution sont des exceptions qui se produisent lors de l’exécution et le développeur ne doit pas essayer de l’attraper ou de l’arrêter. Vous écrivez uniquement du code pour les éviter ou émettez une commande lorsque les critères d’erreur sont remplis. Nous utilisons jet dans le corps de la méthode.

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

Cependant, pour les exceptions vérifiées, la machine virtuelle Java s'attend à ce que vous la gériez et générera une erreur de compilation si elle n'est pas gérée. Ainsi, vous déclarez qu'elle lève ce type d'exception dans la méthode clone ().

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

Même réponse que ci-dessus mais avec un plaisir de copier-coller :

 public class GsonBuilderHelper { // THROWS: method throws the specified (checked) exception public static Object registerAndRun(Ssortingng 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.toSsortingng()); throw new Exception(e); // <---- THROW: instance of class Throwable. } return natural; } }