Explication détaillée de la différence d'utilisation des mots-clés throw et throws dans la gestion des exceptions Java

Lancement d'exceptions
Il existe trois formes de lancement d'exceptions, l'une est le lancement, l'autre est le lancement, et le système lance automatiquement des exceptions. Vous trouverez ci-dessous les similitudes et les différences entre eux.
Le système génère automatiquement des exceptions
Lorsqu'il y a des erreurs logiques, des erreurs doctrinales ou des erreurs de conversion de type dans les instructions du programme, le système lancera automatiquement des exceptions. Par exemple :

public static void main(String[] args) {
    int a = 5, b =0;
    System.out.println(5/b);
    //function();
}

Le système lancera automatiquement ArithmeticException :

Exception in thread "main" java.lang.ArithmeticException: / by zero
at test.ExceptionTest.main(ExceptionTest.java:62)

Un autre exemple est

public static void main(String[] args) {
    String s = "abc";
    System.out.println(Double.parseDouble(s));
    //function();
}

Le système lancera automatiquement une NumberFormatException :

Exception in thread "main" java.lang.NumberFormatException: For input string: "abc"
at sun.misc.FloatingDecimal.readJavaFormatString(FloatingDecimal.java:1224)
at java.lang.Double.parseDouble(Double.java:510)
at test.ExceptionTest.main(ExceptionTest.java:62)

throw
throw est une instruction qui lève une exception.
Syntaxe : throw (objet d'exception);
Par exemple :

throw e;

est généralement utilisé lorsque le programmeur lance activement un type spécifique lorsqu'une certaine logique se produit dans le exception au programme. Par exemple :

public static void main(String[] args) {
    String s = "abc";
    if(s.equals("abc")) {
      throw new NumberFormatException();
    } else {
      System.out.println(s);
    }
    //function();
}

lèvera une exception :

Exception in thread "main" java.lang.NumberFormatException
at test.ExceptionTest.main(ExceptionTest.java:67)

throws
throws est une instruction indiquant que la méthode peut lever une exception. (Utilisé lors de la déclaration d'une méthode, il indique que la méthode peut lever une exception)
Syntaxe : [(modifier)](type de valeur de retour)(nom de la méthode)([liste de paramètres])[throws(classe d'exception)]{ ......}
Par exemple :

public void function() throws Exception{......}

Lorsqu'une méthode peut lever une sorte d'exception, utilisez throws pour déclarer l'exception qui peut être levée, et puis laissez à la couche supérieure le soin d'appeler son programme de méthode pour le traitement. Par exemple :

public static void function() throws NumberFormatException{
    String s = "abc";
    System.out.println(Double.parseDouble(s));
  }
    
  public static void main(String[] args) {
    try {
      function();
    } catch (NumberFormatException e) {
      System.err.println("非数据类型不能转换。");
      //e.printStackTrace();
    }
}

Le résultat du traitement est le suivant :
Les types non-données ne peuvent pas être convertis.
Comparaison entre throw et throws
1. Throws apparaît dans l'en-tête de la fonction de méthode tandis que throw apparaît dans le corps de la fonction.
2. Throws représente une possibilité d'exceptions, mais ces exceptions ne se produisent pas nécessairement ; throw signifie qu'une exception est levée, et l'exécution de throw doit lancer une sorte d'objet d'exception.
3. Les deux sont des moyens passifs de gérer les exceptions (le négatif ici ne signifie pas que cette méthode est mauvaise). Ils ne font que lancer ou peuvent lancer des exceptions, mais les exceptions ne seront pas gérées par la fonction, et les exceptions le seront en fait. être géré par l’appel de couche supérieure de la fonction.

Bonnes habitudes de programmation :
1. Lors de l'écriture d'un programme, vous utilisez généralement try{...}catch{...} pour intercepter la partie où une exception peut se produire et l'exécuter.
2. Après avoir détecté l'exception avec try{...}catch{...}, vous devez la traiter dans catch{...}, même s'il s'agit de l'instruction de sortie la plus simple, ou d'une pile d'entrée e.printStackTrace. ();
3. Si vous détectez des exceptions dans le flux d'entrée et de sortie IO, assurez-vous d'ajouter enfin{...} après try{...}catch{...} pour mettre l'entrée La sortie le flux est fermé ;
4. Si une certaine exception est levée en utilisant throw dans le corps de la fonction, il est préférable d'ajouter une instruction d'exception throws au nom de la fonction, puis de la transmettre à la fonction de niveau supérieur qui l'appelle. pour le traitement.

Exemple :

lance E1, E2, E3 indique simplement au programme que cette méthode peut lever ces exceptions, et l'appelant de la méthode devra peut-être gérer ces exceptions, et ces les exceptions E1, E2 et E3 peuvent être générées par le corps de la fonction.
throw indique clairement que cette exception doit être levée à cet endroit.

Par exemple :

void doA(int a) throws IOException,{
      try{
         ......
 
      }catch(Exception1 e){
       throw e;
      }catch(Exception2 e){
       System.out.println("出错了！");
      }
      if(a!=b)
       throw new Exception3("自定义异常");
}

Trois exceptions peuvent survenir dans le bloc de code, (Exception1,Exception2,Exception3).
Si une exception Exception1 se produit, elle sera interceptée puis levée, et elle sera gérée par l'appelant de la méthode.
Si une exception Exception2 se produit, la méthode la gère elle-même (c'est-à-dire System.out.println("Une erreur s'est produite!");). Par conséquent, cette méthode ne lancera plus d'exceptions Exception2 et void doA() renvoie Exception1, Exception2 dans Exception3 n'a pas besoin d'être écrite.
L'exception Exception3 est une certaine erreur logique dans la méthode. Le programmeur l'a gérée lui-même. Si l'exception Exception3 est levée dans le cas d'une erreur logique, l'appelant de la méthode doit également gérer cette exception.

L'instruction throw est utilisée dans le corps de la méthode pour indiquer qu'une exception est levée, qui est gérée par les instructions dans le corps de la méthode.
L'instruction throws est utilisée après la déclaration de la méthode pour indiquer qu'une exception sera levée et sera gérée par l'appelant de la méthode.

throws déclare principalement que cette méthode lèvera ce type d'exception, afin que son appelant sache intercepter cette exception.
throw est une action spécifique consistant à lancer une exception, il lève donc une instance d'exception.

les lancers montrent que vous avez cette possibilité et cette tendance.
Si vous lancez quelque chose, vous transformez cette tendance en réalité.

S'il s'agit d'une exception système, vous n'avez rien à faire, ou vous pouvez lancer une exception pour la méthode, car les exceptions système peuvent être automatiquement interceptées par le système, si cette exception est résolue dans le cadre du processus. méthode ou remis à la méthode ? La fonction de niveau supérieur résout le problème et l'effet est le même. Mais j'ai vérifié beaucoup d'informations, et même si une exception est levée et peut être interceptée par le système, il est toujours recommandé d'écrire un lancer pour la méthode, car cela peut permettre aux autres programmeurs de savoir quelles exceptions se produiront lors de l'exécution d'un grand tâche.

S'il s'agit d'une exception auto-définie, vous devez utiliser throws pour lever l'exception qui peut être levée par la méthode, sinon la compilation signalera une erreur.

Pour des explications plus détaillées sur les différences d'utilisation entre les mots-clés throw et throws dans la gestion des exceptions Java, veuillez faire attention au site Web PHP chinois pour les articles connexes !