Qu'est-ce qu'une exception en Java ?

Qu'est-ce qu'une exception ?

Un code mal structuré ne peut pas s'exécuter, c'est la philosophie de base de Java.

Le moment idéal pour trouver les erreurs est au moment de la compilation. Cependant, le compilateur ne peut pas trouver toutes les erreurs et les problèmes restants doivent être résolus pendant l'exécution du programme. Cela nécessite que l'erreur puisse transmettre les informations appropriées à un destinataire spécifique pour traitement d'une manière ou d'une autre.

Le but de la gestion des exceptions en Java est de simplifier la génération de programmes volumineux et fiables en utilisant une petite quantité de code. De cette façon, il n'y a pas d'erreurs non gérées dans votre application, et cela apporte également une évidence. avantage : complexité réduite du code de gestion des erreurs.

Anormal, au sens littéral, signifie inattendu. Pour le comprendre au niveau du code, cela empêche la méthode ou la portée actuelle de continuer à s'exécuter. Les exceptions sont des événements qui empêchent un programme de fonctionner dans son exécution prévue. Il existe trois types d'exceptions : les exceptions vérifiées, les erreurs et les exceptions d'exécution.

En Java, les exceptions sont gérées comme des objets et leur classe de base est Throwable.

Types d'exceptions en Java

Java dérive les exceptions et les erreurs directement de Throwable. L'exception est le type de base qui peut être généré. Des exceptions de type exception peuvent être générées dans les bibliothèques de classes Java, les méthodes et les échecs d'exécution. L'exception représente une exception récupérable, qui peut être interceptée par le compilateur ; l'erreur représente une erreur de compilation et du système, indiquant qu'une erreur grave s'est produite lors du fonctionnement du système, ce qui est une erreur irrécupérable puisqu'il s'agit d'une erreur grave. le niveau JVM, donc cette erreur entraîne l'arrêt de l'exécution du programme. Les exceptions sont divisées en exceptions vérifiées et exceptions d'exécution.

Le diagramme de hiérarchie structurelle de la classe d'exception est le suivant :

L'exception typique de RuntimeException (exception d'exécution) inclut NullPointerException, ClassCastException (exception de conversion de type), IndexOutOfBoundsException. (exception hors limites), IllegalArgumentException (exception de paramètre illégal), ArrayStoreException (exception de stockage de tableau), AruthmeticException (exception arithmétique), BufferOverflowException (exception de dépassement de tampon), etc.

Non-RuntimeException (exceptions vérifiées) incluent IOException, SQLException, InterruptedException (exception interrompue - lorsque le thread appelant est en veille), NumberFormatException (exception de formatage des nombres), etc.

Selon la méthode de vérification du compilateur, les exceptions peuvent être divisées en exceptions vérifiées (CheckedException) et exceptions non vérifiées (UncheckedException). La combinaison de Error et RuntimeException est appelée UncheckedException. Elle est ainsi appelée car le compilateur ne vérifie pas si la méthode gère ou renvoie ces deux types d'exceptions. Par conséquent, aucune erreur ne sera signalée si ce type d'exception se produit lors de la compilation. est virtuel La machine fournit des méthodes de traitement. À l'exception des deux types d'exceptions Error et RuntimeException, les autres exceptions sont appelées exceptions vérifiées.

Comment Java gère les exceptions

1. 🎜>Pour les exceptions de type vérifié, nous devons soit les gérer, soit utiliser des lancers dans l'en-tête de la méthode.

public static void createFile() throws IOException{
    File file = new File("C:/test.txt");
    if(!file.exists()){
            file.createNewFile();
    }
}
public static void main(String[] args) {
    try {
        createFile();
    } catch (IOException ex) {
        // handle exception here
    }
}

Quelques points à noter concernant catch :

1). Le type d'exception du paramètre doit être la classe Throwable ou sa sous-classe.

2) Pour les instructions catch de haut en bas, les types de paramètres doivent être dans l'ordre de la sous-classe à la classe parent, car une fois qu'un type correspond, les captures suivantes seront ignorées. Par exemple, IOException doit être placé avant Exception, sinon le compilateur signalera une erreur.

3), il peut y avoir une ou plusieurs instructions catch, même s'il y a une instruction final, il ne peut y avoir aucune instruction catch, comme try-finally.

Si vous souhaitez intercepter plusieurs exceptions, vous pouvez utiliser plusieurs instructions catch et JDK7 proposera ultérieurement une autre méthode : la multi-catch.

try{
    // other code
} catch (IOException | SQLException ex) {
    throw ex;  
}

4). N’ignorez pas les exceptions. Un bloc catch vide annulera l'objectif de l'exception, sauf lors de la fermeture de FileInputStream, car vous n'avez pas modifié l'état du fichier, vous n'avez donc pas à effectuer d'actions de récupération et les informations requises ont été lues à partir du fichier. . Il n'est donc pas nécessaire de mettre fin aux opérations en cours.

Quelques points à noter à propos de final :

1). Le code de final sera toujours exécuté à moins que la machine virtuelle ne se ferme lorsqu'une instruction try ou catch est exécutée (System.exit(1). )).

2). Le bloc final peut effectuer un travail de nettoyage des ressources, comme la fermeture de fichiers, la fermeture de curseurs, etc.

3), enfin le blocage n'est pas nécessaire.

De plus, si l'instruction return est exécutée à la fois dans les blocs try et final, la valeur de retour dans final sera renvoyée.

2. Chaîne anormale

常常想要在捕获一个异常后抛出另外一个异常，并且希望把原始异常信息保存下来，这就是异常链。在JDK1.4以后，Throwable子类在构造器 中可以接受一个cause对象作为参数，表示原始异常，通过这样把原始异常传递给新的异常，使得即使在当前位置创建并抛出了新的异常，也能通过这个异常链 追踪到异常最初发生的位置。

但在Throwable子类中，只有Error, Exception, RuntimeException三类异常类提供了带cause参数的构造器，其它类型的异常则需要通过initCause()方法。例如定义了CustomException类，可以这样使用：

CustomException cmex = new CustomException();
cmex.initCause(new NullPointerException);
throw cmex;

这样一来，CustomException继承自Exception或RuntimeException，就属于自定义异常了。

一般来说，自定义异常的作用有以下情形：

1)、将检查型异常转换为非检查型异常。

2)、在产生异常时封装上下文信息、定义异常码、收集环境对象，有利于信息的传递。

异常使用指南

1、在知道该如何处理的情况下才捕获异常。

2、自定义异常类型，用以封装所有的检查型异常。

3、在程序的边界进行异常捕获。如服务端相应客户端的请求，在出口处catch内部有可能产生的异常，并统一throw一个封装过的异常给客户端，免得暴露服务端敏感信息。

4、只针对异常的情况才使用异常。不要在所有的代码中习惯性地使用try-catch，因为这会影响性能。

5、抛出与抽象相对的异常。如果方法抛出的异常与它执行的任务没有明显的联系，这种情形会使人不知所措。为了避免这个问题，更高层的实现应该捕获 低层的异常，同时抛出可以按照高层抽象进行解释的异常，这种做法被称为异常转译（exception translation），如下：

try{
    // use lower-level abstraction to do our bidding
} catch(LowerLevelException ex){
    throw new HigherLevelException(...);
}

另外一种特殊的异常转译称为异常链，上面已作描述。如果低层的异常对于调试导致高层异常的问题非常有帮助，使用异常链就很合适。高层的异常提供访问方法（Throwable.getCause）来获得低层的异常。

6、每个方法抛出的异常要有文档描述。利用Javadoc的@throws标记，记录抛出每个异常的条件。如果一个方法可能抛出多个异常，不要使 用这些异常类的某个超类。如不要声明一个方法“throws Exception”或“throws Throwable”，这将没有任何指导信息。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!