Exemple d'analyse du mécanisme de gestion des exceptions Java

Le principe sous-jacent du mécanisme de gestion des exceptions

• lève une exception. Lors de l'exécution d'une méthode, si une exception est envoyée, cette méthode génère un objet représentant l'exception, arrête le chemin d'exécution actuel et soumet l'exception à jre.

• Catch exception : une fois que jre a obtenu l'exception, il feint le code correspondant pour gérer l'exception. jre recherche dans la pile d'appels de la méthode et revient en arrière à partir de la méthode qui a généré l'exception jusqu'à ce qu'il trouve le code de gestion des exceptions correspondant.

Diagramme d'héritage des exceptions

Oak, maintenant que nous savons quelle est la définition de l'exception, comment devrions-nous intercepter les exceptions puis les gérer.

Gestion des exceptions

1. Structure Try-catch-finally

Tout d'abord, regardons un morceau de code :

package AbnormalTest;

import java.util.InputMismatchException;
import java.util.Scanner;

public class test1 {

    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);

        try {
            System.out.print("请输入被除数：");
            int a = input.nextInt();
            System.out.print("请输入除数：");
            int b = input.nextInt();
            int sum = b/a;
            System.out.println("结果是："+sum);
            System.out.println("程序无异常，执行完毕！");
        }catch (Exception e){               //通用异常
            //printStackTrace()方法是将堆栈异常的错误信息打印出来(后期学习框架后我们一般提交或 者回滚事务)
            e.printStackTrace();
            System.out.println("程序异常，请重试！");
            return ;
        }finally {
            //不管是否发生了异常，都会执行finally内的代码，通常用于资源的关闭
            System.out.println("------------------------------");
            System.out.println("程序结束，资源已经关闭，欢迎再次使用");
            input.close();   //关闭Scanner对象，节省资源
        }
    }

}

Explication du code :

Il y a une structure try-catch-finally dans le code ci-dessus. leurs fonctions respectives ?

try : nous utilisons try pour inclure du code susceptible de provoquer des exceptions

catch : tant qu'une exception se produit lors de l'exécution du code dans le bloc de code try, catch sera saisi pour capturer l'exception

finalement : peu importe comment le code précédent est exécuté, le bloc de code final sera exécuté ! !

Exemple de résultats en cours d'exécution :

Temps normal :

Temps anormal :

Lorsque le dividende est de 0, une exception sera déclenchée et entrée dans catah pour capture, mais qu'il y ait ou non une exception, le le programme sera finalement exécuté Résultat : Le programme est terminé, la ressource a été fermée, bienvenue à réutiliser

2. Multi-catch gère différentes exceptions :

Nous savons qu'il peut y avoir plus d'une exception dans un morceau de code. Par exemple, dans le code ci-dessus, il peut y avoir un dividende de 0. Exception, il peut également y avoir une exception de saisie lorsque des caractères sont saisis pour le calcul, ou il peut y avoir une exception de formatage des nombres, etc. De cette façon, nous pouvons utiliser le multi-catch pour intercepter l'exception :

Ou prendre le code ci-dessus comme exemple :

import java.util.InputMismatchException;
import java.util.Scanner;
public class test1 {

    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);

        try {
            System.out.print("请输入被除数：");
            int a = input.nextInt();
            System.out.print("请输入除数：");
            int b = input.nextInt();
            int sum = b/a;
            System.out.println("结果是："+sum);
            System.out.println("程序无异常，执行完毕！");

        }catch (InputMismatchException  e){                    //多重catch结构，这里捕捉输入异常
            e.printStackTrace();
            System.out.println("程序输入异常，请重试！");
        }catch (Exception e){                                 //这里捕捉通用异常（其他异常都可以在这里进行捕捉）
            e.printStackTrace();
            System.out.println("程序异常，请重试！");
            return ;
        }finally {
            //不管是否发生了异常，都会执行finally内的代码，通常用于资源的关闭
            System.out.println("------------------------------");
            System.out.println("程序结束，资源已经关闭，欢迎再次使用");
            input.close();   //关闭Scanner对象，节省资源
        }
    }

}

Lorsque l'entrée n'est pas Lorsqu'il s'agit de nombres :

De cette façon, nous pouvons voir qu'elle a été intercepté dans le premier catch

Trois, throws déclare une exception/lance une exception :

Supposons que je définisse une méthode pour informer la méthode. Une sorte d'exception (exception déclarée) peut être envoyée, et l'appelant doit gérer l'exception lorsque appeler la méthode.

Nous définissons d'abord une classe d'erreur :

Classe d'étudiant :

package ExceptionText;

/**
 * 异常测试
 */

public class Student {

    private String name;
    private int age;
    private char sex;


    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public char getSex() {
        return sex;
    }

    public void setAge(int age) throws Exception {
        if (age < 101 && age > 0) {
            this.age = age;
        } else {
            throw new Exception("年龄输入有误！");
        }
    }
    public void setSex(char sex) throws Exception {
        if (sex == &#39;男&#39; || sex == &#39;女&#39;) {
            this.sex = sex;
        } else {
            throw new Exception("性别输入有误");
        }

    }
}

Classe de test :

package ExceptionText;

public class TestMain {
    public static void main(String[] args) {

        Student stu = new Student();
        stu.setName("小红");
        try {
            stu.setAge(50);
            stu.setSex('k');
            System.out.println("我叫："+stu.getName()+"年龄："+stu.getAge()+"我的性别是："+stu.getSex());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Lorsque l'entrée et la sortie sont correctes :

Lorsque la saisie de l'âge est incorrecte :

Lorsque la genre Lorsque la saisie est incorrecte :

Remarque : S'il y a plusieurs exceptions, la première qui se produit sera levée.

4. Exceptions personnalisées :

Lorsque la sous-classe d'exception d'exécution de RuntimeException ne peut pas répondre à nos besoins, nous pouvons également personnaliser l'exception d'exécution et générer des informations d'exception personnalisées pour répondre à nos besoins, mais Remarque : les exceptions d'exécution personnalisées doivent hériter de RuntimeException ! ! !

Classe d'exception personnalisée :

//这个类是继承了RuntimeException
public class AgeException extends RuntimeException {
   //构造方法
   public AgeException(String message) {
       super(message);
   }
}

Classe d'informations sur l'étudiant :

package CustomizeException;

public class Student {

    private String name;
    private int age;
    private char sex;

    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public char getSex() {
        return sex;
    }
    //方法
    //使用throws 来声明异常，就是这个方法内可能存在异常，先事先声明
    public void setAge(int age) throws Exception {
        if (age < 101 && age > 0) {
            this.age = age;
        } else {            //如果不符合上面的if判断
            throw new Exception("年龄输入有误！");   //这里就要用thrwo 来抛出异常，
        }
    }

    public void setSex(char sex) throws Exception {
        if (sex == &#39;男&#39; || sex == &#39;女&#39;) {
            this.sex = sex;
        } else {
            throw new AgeException("这是自定义异常，性别输入有误");
        }
    }
}

Classe de test :

package ExceptionText;
public class TestMain {
    public static void main(String[] args) {

        Student stu = new Student();
        stu.setName("小红");
        try {
            stu.setAge(18);
            stu.setSex('女');
            System.out.println("我叫："+stu.getName()+"年龄："+stu.getAge()+"我的性别是："+stu.getSex());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Le code de cette partie est cohérent avec la troisième partie ci-dessus. Vous pouvez vous référer à l'exemple ci-dessus.

5. Anomalies courantes

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!