Comprendre brièvement les méthodes de levée d'exceptions dans la programmation Java

Tout code Java peut générer des exceptions, telles que du code écrit par vous-même, du code du package de l'environnement de développement Java ou du système d'exécution Java. N'importe qui peut lever une exception via l'instruction throw de Java. Toute exception levée depuis une méthode doit utiliser une clause throws.

1. throws lève une exception

Si une méthode peut lever une exception mais n'a pas la capacité de gérer cette exception, vous pouvez utiliser la clause throws dans la déclaration de la méthode pour la déclarer. lève une exception. Par exemple, une voiture peut mal fonctionner pendant qu'elle roule. La voiture elle-même ne peut pas gérer le dysfonctionnement, alors laissez le conducteur s'en occuper.

L'instruction throws est utilisée lors de la définition d'une méthode pour déclarer le type d'exception que la méthode lancera. Si le type d'exception est lancé, la méthode est déclarée pour lever toutes les exceptions. Plusieurs exceptions peuvent être séparées par des virgules. Le format de syntaxe de l'instruction throws est :

methodname throws Exception1,Exception2,..,ExceptionN liste d'exceptions. Lorsqu'une méthode lève une exception à partir de la liste d'exceptions, la méthode ne gère pas les exceptions de ces types et de leurs sous-classes, mais les renvoie à la méthode qui appelle la méthode pour la gestion. Par exemple :


Après avoir utilisé le mot-clé throws pour lancer une exception à l'appelant, si l'appelant ne veut pas gérer l'exception, il peut continuer à la lancer vers le haut, mais à la fin il faut être un appelant capable de gérer l'exception.

import java.lang.Exception; 
public class TestException { 
  static void pop() throws NegativeArraySizeException { 
    // 定义方法并抛出NegativeArraySizeException异常 
    int[] arr = new int[-3]; // 创建数组 
  } 
   
  public static void main(String[] args) { // 主方法 
    try { // try语句处理异常信息 
      pop(); // 调用pop()方法 
    } catch (NegativeArraySizeException e) { 
      System.out.println("pop()方法抛出的异常");// 输出异常信息 
    } 
  } 
   
}

La méthode pop ne gère pas l'exception NegativeArraySizeException, mais est gérée par la fonction main.

Règles de lancement pour lancer des exceptions :

1) S'il s'agit d'une exception non vérifiée (exception non vérifiée), c'est-à-dire Error, RuntimeException ou leurs sous-classes, vous pouvez la déclarer sans utiliser le mot-clé throws L'exception à lever passera toujours sans problème lors de la compilation, mais sera levée par le système au moment de l'exécution.

2) Toutes les exceptions vérifiées que la méthode peut lever doivent être déclarées. Autrement dit, si une méthode peut avoir une exception vérifiable, utilisez soit une instruction try-catch pour l'attraper, soit une instruction de clause throws pour la lancer, sinon cela provoquera une erreur de compilation

3) Uniquement lorsque une exception est levée, seul l'appelant de cette méthode doit gérer ou relancer l'exception. Lorsque l'appelant de la méthode est incapable de gérer l'exception, il doit continuer à la lancer au lieu d'avaler l'exception.

4) La méthode appelante doit suivre les règles de gestion et de déclaration de toute exception vérifiable. Si vous remplacez une méthode, vous ne pouvez pas déclarer une exception différente de celle de la méthode remplacée. Toute exception déclarée doit appartenir à la même classe ou sous-classe que l'exception déclarée par la méthode remplacée.

Par exemple :

La base pour juger si une exception peut se produire dans une méthode est la suivante :

1) Il y a une instruction throw dans la méthode. Par exemple, le bloc de code catch de la méthode method7() ci-dessus a une instruction throw.

2) D'autres méthodes sont appelées et d'autres méthodes sont déclarées pour lever une sorte d'exception à l'aide de la clause throws. Par exemple, la méthode method3() appelle la méthode method1() et la méthode method1() déclare lancer IOException. Par conséquent, une IOException peut se produire dans la méthode method3().

2. Utilisez throw pour lancer des exceptions

throw apparaît toujours dans le corps de la fonction et est utilisé pour lancer une exception de type Throwable. Le programme se terminera immédiatement après l'instruction throw et les instructions qui la suivent ne pourront pas être exécutées. Ensuite, il recherchera de l'intérieur un bloc try contenant une clause catch correspondante dans tous les blocs try la contenant (éventuellement au niveau supérieur). fonction appelante).

Nous savons que les exceptions sont des objets d'instance de la classe d'exception et nous pouvons les lancer via l'instruction throw. Le format de syntaxe de cette instruction est

throw new exceptionname;

Par exemple, lancer un objet d'exception de la classe IOException :

throw new IOException;

Il Il convient de noter que throw ne peut être qu'une instance d'objet de la classe throwable Throwable ou de ses sous-classes. L'opération suivante est erronée :

throw new String(“exception”)

C'est parce que String n'est pas une sous-classe de la classe Throwable.

Si une exception vérifiée est levée, le type d'exception que la méthode peut lever doit également être déclaré dans l'en-tête de la méthode. L'appelant de cette méthode doit également vérifier pour gérer l'exception levée.

Si toutes les méthodes lancent les exceptions obtenues couche par couche, la JVM finira par les gérer. Le traitement est également très simple, qui consiste à imprimer le message d'exception et les informations de la pile. Si une erreur ou une RuntimeException est levée, l'appelant de la méthode peut choisir de gérer l'exception.

Pour plus d'articles sur la simple compréhension de la manière de lancer des exceptions dans la programmation Java, veuillez faire attention au site Web PHP chinois !

package Test;
import java.lang.Exception;
public class TestException {
  static int quotient(int x, int y) throws MyException { // 定义方法抛出异常
    if (y < 0) { // 判断参数是否小于0
      throw new MyException("除数不能是负数"); // 异常信息
    }
    return x/y; // 返回值
  }
  public static void main(String args[]) { // 主方法
    int a =3;
    int b =0; 
    try { // try语句包含可能发生异常的语句
      int result = quotient(a, b); // 调用方法quotient()
    } catch (MyException e) { // 处理自定义异常
      System.out.println(e.getMessage()); // 输出异常信息
    } catch (ArithmeticException e) { // 处理ArithmeticException异常
      System.out.println("除数不能为0"); // 输出提示信息
    } catch (Exception e) { // 处理其他异常
      System.out.println("程序发生了其他的异常"); // 输出提示信息
    }
  }
   
}
class MyException extends Exception { // 创建自定义异常类
  String message; // 定义String类型变量
  public MyException(String ErrorMessagr) { // 父类方法
    message = ErrorMessagr;
  }
   
  public String getMessage() { // 覆盖getMessage()方法
    return message;
  }
}