Gestion des exceptions: jet, lance et Throwable

Question

Quelqu'un peut vous expliquer quelles sont les différences entre throw, throws et Throwable et quand utiliser qui?

Answer 1

• throws. Utilisé lors de l'écriture des méthodes, de déclarer que la méthode en question jette spécifié (cochée) exception

  Contrairement aux exceptions vérifiées, les exceptions d'exécution (NullPointerExceptions etc) peuvent être jetées sans avoir la méthode declare throws NullPointerException.

• throw: Instruction à fait jeter l'exception. (Ou plus précisément, le Throwable ).

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

Exemple:

---

• Throwable. Classe A que vous devez étendre afin de créer vos propres, coutume, throwable

Exemple:

---

• exception-tutorial officiel

Answer 2

• throw:. Déclaration à jeter l'objet t où t instanceof java.lang.Throwable doit être vrai
• throws:. Une signature de méthode jeton pour spécifier des exceptions vérifiés thrown par cette méthode
• java.lang.Throwable:. Le type de parent de tous les objets qui peuvent être projetés (et happés)

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

Answer 3

Ce vraiment facile à comprendre.

java.lang.Throwable :

  

La classe est Throwable   la superclasse de toutes les erreurs et   exceptions dans le langage Java. Seulement   les objets qui sont des exemples de cette   classe (ou une de ses sous-classes) sont   lancée par la machine virtuelle Java ou   peut être jeté par la Java   déclaration throw.   De même, seule cette classe ou l'une des   ses sous-classes peuvent être l'argument   entrez dans une clause de catch.    Plus

Le mot clé lance est utilisé dans la déclaration de méthode, cette préciser quel type d'exception [classe Throwable] nous pouvons attendre de cette méthode.

Le mot clé lancer est utilisé pour jeter un objet qui est une instance de la classe Throwable.

---

De peur que voir par exemple:

Nous créons une classe ourself d'exception

public class MyException super Exception {

}

nous créons une méthode qui crée un objet de notre classe d'exception et lance en utilisant le mot clé lancer .

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

Quand nous allons utiliser la méthode throwMeAException(), nous sommes forcés de prendre soin de manière spécifique parce que nous avons les informations qu'il jette quelque chose, dans ce cas, nous avons trois options.

La première option utilise essayer de bloc 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
   }
}

Deuxième option est de 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.

   }

troisième option est d'attraper et de re-jeter l'exception

private void catchException() throws Exception  {

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

---

Reprise, lorsque vous avez besoin d'arrêter une action que vous pouvez jeter l'exception qui va revenir jusqu'à ce n'est pas serveur par un bloc try-catch. Chaque fois que vous utilisez la méthode qui lance une exception, vous devez manipuler par bloc try-catch ou ajoutez les déclarations à vos méthodes.

L'exception de cette règle sont java.lang.RuntimeException ceux-ci ne doivent pas être déclarés. Ceci est une autre histoire que l'aspect de l'utilisation d'exception.

Answer 4

Jeté - Il est utilisé pour lancer une instruction throw Exception.The nécessite un seul argument: un objet de classe throwable

lance - Il est utilisé pour que la méthode précise peut jeter exception

Throwable - Ceci est la superclasse de toutes les erreurs et exceptions dans le langage Java. vous pouvez jeter uniquement les objets qui dérivent de la classe Throwable. throwable contient un instantané de la pile d'exécution de son fil au moment où il a été créé

Answer 5

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

Comment lancer des exceptions

Answer 6

Lancer:

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

throw new MyException("Exception!);

Lancers:

Il doit être utilisé lorsque vous ne l'utilisez l'instruction catch try dans votre code, mais vous savez que cette classe est capable de lancer telle ou telle exception (exceptions seulement vérifiés). En cela, vous n'utilisez pas essayer bloc catch mais écrire en utilisant la clause de jet au point approprié dans votre code et l'exception est renvoyée à l'appelant de la méthode et est gérée par elle. De plus, le mot clé throws est utilisé lorsque la fonction peut lancer une exception contrôlée.

public void myMethod(int param) throws MyException 

Answer 7

Il existe 2 principaux types d'exceptions:
Exceptions d'exécution (non cochée) : par exemple. NullPointerException, ClassCastException, ..
Exceptions cochés: par exemple. FileNotFoundException, CloneNotSupportedException, ..

Exceptions d'exécution sont des exceptions qui se produisent lors de l'exécution et le développeur ne devrait pas essayer de l'attraper ou l'arrêter. Vous seul code écrire pour les éviter ou d'émettre une commande lancer , lorsque les critères d'erreur est atteint. Nous utilisons jeter à l'intérieur du 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 cochés, la machine virtuelle Java vous attend à gérer et accorderez compilateur erreur en cas de manipulation si vous déclarez qu'il jette ce type d'exception comme on le voit ci-dessous dans la méthode clone ().

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

Answer 8

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

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