Comment gérer les types d'exceptions en Java

1. Description de l'exception

Un événement inattendu se produit lorsque le programme est en cours d'exécution, ce qui empêche le programme de s'exécuter normalement comme prévu par le programmeur. Lorsqu'une exception se produit, le programme est laissé à lui-même et se ferme immédiatement. En Java, c'est-à-dire les erreurs qui se produisent lors de la compilation ou de l'opération Java ou pendant l'opération.

Java offre une meilleure solution : un mécanisme de gestion des exceptions.

Le mécanisme de gestion des exceptions permet au programme de gérer les exceptions de manière ciblée selon la logique de gestion des exceptions prédéfinie du code lorsqu'une exception se produit, afin que le programme puisse revenir à la normale et poursuivre l'exécution autant que possible, tout en gardant le code clair.

Des exceptions en Java peuvent être provoquées lorsque des instructions dans une fonction sont exécutées, ou elles peuvent être levées manuellement par les programmeurs via des instructions throw. Tant qu'une exception se produit dans un programme Java, un objet d'exception du type correspondant sera utilisé. . En encapsulant l'exception, le JRE tentera de trouver un gestionnaire d'exception pour gérer l'exception.

• L'exception fait référence aux situations anormales qui se produisent pendant le fonctionnement.

• Utiliser des classes en java pour décrire des situations anormales et encapsuler des objets.

• Une classe qui décrit des situations anormales devient une classe d'exception.

• Séparez le code normal et le code de gestion des problèmes pour améliorer la lisibilité.

• En fait, les exceptions sont Java qui encapsule les problèmes dans des objets grâce à une pensée orientée objet et utilise des classes d'exception pour les décrire.

2. Système d'exceptions

Deux grandes catégories :

• hrowable : les exceptions pouvant être lancées, qu'il s'agisse d'une erreur ou d'une exception, doivent être levées lorsqu'un problème survient, afin que l'appelant puisse le connaître et le gérer.

• La caractéristique de ce système est que Throwable et toutes ses sous-classes sont jetables.

Que signifie exactement la possibilité de lancer ? Comment refléter la possibilité de lancer ?

• se traduit par deux mots-clés.

• throws throw Toutes les classes et objets pouvant être exploités par ces deux mots-clés sont jetables.

• Sous-classe 1 Ne peut généralement pas être traitée. ————Erreur

• Caractéristiques : C'est un problème sérieux posé par jvm Lorsque ce genre de problème survient, il n'est généralement pas traité de manière ciblée, et le programme est directement modifié.

• Sous-classe 2) peut le gérer. ——Exception, le problème est renvoyé à l'appelant, celui qui le lance à qui.

• Caractéristiques : Les noms de suffixe des sous-classes sont tous suffixés du nom de leur classe parent, ce qui est très lisible !

Exemple : par exemple, personnalisez une exception avec un index négatif et encapsulez-la dans un objet en utilisant la pensée orientée objet.

• Remarque : Si une classe est appelée classe d'exception, elle doit hériter de la classe d'exception. Parce que seules les sous-classes du système d'exceptions peuvent être lancées.

class FuShuIndex extends Exception{
                //构造函数 和类名一样
                FuShuIndex(){  
                }
                //定义一个带参数的构造函数
                FuShuIndex(String msg){
                    //调用Exception中的带参数异常函数
                    super(msg);  
                }
            }
            主函数 throws FuShuIndex：{
               int[] arr = new int[3];
               method(arr,-7);
            }
            public static int method(int[] arr,int index) throws arrIndexexception {
                 if (index<0){
                    throw new arrIndexexception("数组的角标不能为负数");
                 }
                return arr[index];
            }

3. Classification des exceptions :

Les exceptions détectées lors de la compilation sont également Exception et ses sous-classes, à l'exception de la sous-classe spéciale RuntimeException, la compilation échoue sans traitement !

• Une fois que ce type de problème se produit, nous espérons le détecter au moment de la compilation afin que ce type de problème puisse être traité en conséquence, afin que de tels problèmes puissent être traités de manière ciblée.

Exceptions non détectées lors de la compilation (exceptions d'exécution) : RuntimeException et ses sous-classes

• peuvent être traitées ou non, et la compilation peut réussir, et elles seront détectées au moment de l'exécution !

• Ce type de problème se produit parce que la fonction ne peut pas être poursuivie et que l'opération ne peut pas être exécutée. Cela est principalement dû à l'appel ou au changement de l'état interne. Ce type de problème n'est généralement pas traité, et est directement compilé et transmis au moment de l'exécution, le programme est forcé de s'arrêter lorsque l'appelant est en cours d'exécution, et l'appelant est autorisé à corriger le code. La différence entre

throws et throw :

• throws est utilisé dans les fonctions ————Déclaration

• throw est utilisée dans les fonctions. Plusieurs lancers peuvent être séparés par des virgules. ————Throws

• throws lance une classe d'exception et plusieurs exceptions peuvent être levées.

• throw lance un objet d'exception.

4. Forme de capture de gestion des exceptions

Il s'agit d'un moyen de gérer les exceptions de manière ciblée.

Format :

try{
            //需要被检测异常的代码
        }
        catch(异常类 变量)//该变量用于接收发生的异常对象{
            //处理异常代码
        }
        finally{
            //一定会被执行的代码
      }

Exemple

class FuShuIndex extends Exception{
            //构造函数 和类名一样
            FuShuIndex(){  
            }
            //定义一个带参数的构造函数
            FuShuIndex(String msg){
                //调用Exception中的带参数异常函数
                super(msg);  
            }
  }

Fonction principale : Pas besoin de lancers, attrapons nous-mêmes les exceptions

{
           int[] arr = new int[3];
           try{
           method(arr,-7);
           }catch(arrIndexexception a){
                a.printStackTrace();//jvm默认的异常处理机制就是调用异常对象的这个方法。
                System.out.println("数组的角标异常！！！");//自定义捕获后打印的信息
                System.out.println(a.toString());//打印该异常对象的信息
                System.out.println(a.getMessage());//获取我们自定义抛出所定义的信息
                }
  }
public static int method(int[] arr,int index) throws arrIndexexception {
             if (index<0){
                throw new arrIndexexception("数组的角标不能为负数");
             }
            return arr[index];
 }

Un essai correspond à plusieurs catches :

• Dans le cas de catches multiples, le catch de la classe parent doit être placé en bas, sinon la compilation sera vide.

5. Principes de gestion des exceptions

Si une exception qui doit être détectée est levée à l'intérieur d'une fonction, elle doit être déclarée dans la fonction, ou elle doit être interceptée avec try catch dans la fonction, sinon la compilation échouer.

Si la fonction qui déclare une exception est appelée, essayez catch ou throws, sinon la compilation échoue.

Quand attraper ? Quand lance-t-il ?

• Le contenu fonctionnel peut être résolu en utilisant catch.

• Si le problème ne peut pas être résolu, utilisez des lancers pour le dire à l'appelant et celui-ci le résoudra.

一个功能如果抛出了多个异常，那么调用时，必须有对应的多个catch来进行针对性处理。

• 内部有几个需要检测的异常，就抛几个异常，抛出几个就catch几个异常。

六、finally

通常用于关闭（释放）资源。必须要执行。除非jvm虚拟机挂了。

范例：出门玩，必须关门，所以将关门这个动作放在finally里面，必须执行。

凡是涉及到关闭连接等操作，要用finally代码块来释放资源。

try catch finally 代码块组合特点：

• try catch finally：当有资源需要释放时，可以定义finally

• try catch(多个)：当没有资源需要释放时，可以不定义finally

• try finally：异常处理不处理我不管，但是我得关闭资源，因为资源是我开的，得在内部关掉资源。

范例：

try{
                    //连接数据库
                }
                    //没有catch意思不处理异常，只单纯的捕获异常
                finally{
                    //关闭连接
                }

七、异常的应用

老师用电脑讲课范例：

电脑类：

public class Computer {
                private int state = 2;
                public void run() throws lanpingExcption,maoyanExcption{
                    if (state == 1){
                        throw new lanpingExcption("电脑蓝屏啦～");
                    }else if (state == 2){
                        throw new maoyanExcption("电脑冒烟啦～");
                    }
                    System.out.println("电脑启动");
                }
                public void chongqi(){
                    state = 0;
                    System.out.println("重启电脑！");
                }
  }

老师类：

public class Teacher {
            private String name;
            private Computer computer;
            Teacher(String name){
                this.name = name;
                computer = new Computer();
            }

            void teach() throws maoyanExcption{
                try {
                    computer.run();
                    System.out.println(this.name + "开始用电脑讲课了");
                } catch (lanpingExcption l) {
                    l.printStackTrace();
                    computer.chongqi();
                    teach();//重启后再次讲课
                } catch (maoyanExcption m) {
                    m.printStackTrace();
                    test();
                    throw m;
                }
            }

            public void test(){
                System.out.println("大家自己练习去～");
            }

  }

蓝屏异常类：

public class lanpingExcption extends Exception{
            lanpingExcption (String msg){
                 super(msg);
            }
 }

冒烟异常类：

public class maoyanExcption extends Exception {
            maoyanExcption (String msg){
                super(msg);
            }
}

主函数：

public class Testmain {
            public static void main (String[] args){
                Teacher teacher = new Teacher("丁老师");
                try {
                    teacher.teach();
                } catch (maoyanExcption m) {
                    //m.printStackTrace();
                    System.out.println("。。。。。");
                }
            }
    }

八、异常的注意事项：

• 子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类。

• 如果父类抛出多个异常，那么子类只能抛出父类异常的子集。

• 子类覆盖父类，只能抛出父类的异常或者子类。

• 如果父类的方法没有抛出异常，子类覆盖时绝对不能抛。

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!