Causes des exceptions en Java et comment les gérer-javaDidacticiel-php.cn

Causes des exceptions en Java et comment les gérer

Une exception en Java, également connue sous le nom d'exception, est un événement qui se produit lors de l'exécution d'un programme, qui interrompt le flux d'instructions normal du programme en cours d'exécution. Afin de gérer rapidement et efficacement les erreurs d’exécution dans le programme, des classes d’exception doivent être utilisées.

1. Causes et classification des exceptions

1.1 Causes des exceptions

Les exceptions se produisent en Java, principalement pour trois raisons :

(1) Causées par des erreurs d'écriture du code du programme. Exceptions, telles qu'un tableau hors limites, exceptions de pointeur nul, etc. Ces exceptions sont appelées exceptions non vérifiées. Ces exceptions doivent généralement être gérées dans la classe

(2) Exceptions causées par des erreurs internes Java, la machine virtuelle Java génère des exceptions.

(3) Exceptions générées manuellement via l'instruction throw Cette exception est appelée une exception vérifiée, qui est généralement utilisée pour donner à l'appelant de la méthode certaines informations nécessaires

1.2 Classification des exceptions

Causes des exceptions en Java et comment les gérer

(1). ) Throwable : il s'agit de la classe de niveau supérieur du système d'exceptions, qui dérive deux sous-classes importantes, Error et Exception

et les deux sous-classes Error et Exception représentent respectivement les erreurs et les exceptions.

La différence est l'exception non vérifiée et l'exception vérifiée.

(2) La classe Exception est utilisée pour les exceptions pouvant survenir dans les programmes utilisateur. C'est également une classe utilisée pour créer des classes de types d'exceptions personnalisées.

(3) L'erreur définit les exceptions qui ne devraient pas être détectées par le programme dans des circonstances normales. Les exceptions de type Error sont utilisées par le runtime Java pour afficher les erreurs liées au système d'exécution lui-même. Le débordement de pile est un exemple de cette erreur.

Des exceptions peuvent survenir lors de la compilation ou pendant l'exécution du programme. Selon le moment de leur apparition, elles peuvent être divisées en :

Les exceptions d'exécution sont toutes les exceptions de la classe RuntimeException et de ses sous-classes, telles que. NullPointerException, IndexOutOfBoundsException, etc. Ces exceptions sont des exceptions non cochées. Vous pouvez choisir de les capturer ou de ne pas les gérer dans le programme. Ces exceptions sont généralement causées par des erreurs logiques du programme, et le programme doit essayer d'éviter l'apparition de telles exceptions d'un point de vue logique.

Par exemple :

Causes des exceptions en Java et comment les gérer

Les exceptions au moment de la compilation font référence à des exceptions autres que RuntimeException, et elles appartiennent toutes à la classe Exception et à ses sous-classes. Du point de vue de la syntaxe du programme, c'est une exception qui doit être gérée. Si elle n'est pas gérée, le programme ne sera pas compilé. Telles que IOException, ClassNotFoundException, etc. et les exceptions d'exception définies par l'utilisateur. Généralement, aucune exception vérifiée personnalisée n'est utilisée.

Par exemple

class Person implements Cloneable{
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class Test01 {

    public static void main(String[] args) {
        Person person =new Person();
        Person person1 =(Person) person.clone();
    }
}

Copier après la connexion

Causes des exceptions en Java et comment les gérer

2. Gestion des exceptions

2.1 Programmation défensive

Des erreurs existent objectivement dans le code. Ainsi, lorsqu'il y a un problème avec le programme, le programmeur doit être averti rapidement.

. Notification Il existe deux manières :

(1) LBYL effectue des vérifications suffisantes avant l'opération

private static int pide() {
        int a = 0, b = 0;
        Scanner scanner = new Scanner(System.in);
        a = scanner.nextInt();
        b = scanner.nextInt();
        if (b == 0) {
            System.out.println("除数为0");
            return 0;
        } else {
            return a / b;
        }
    }

Copier après la connexion

Inconvénients : les codes de processus normal et de traitement des erreurs sont mélangés et le code global n'est pas clair.

(2) L'EAFP fonctionne en premier et gère les problèmes après les avoir rencontrés

private static int pide() {
        int a = 0, b = 0;
        try (Scanner scanner = new Scanner(System.in)) {
            a = scanner.nextInt();
            b = scanner.nextInt();
            return a / b;
        } catch (ArithmeticException exception) {
            System.out.println("除数为0");
            return 0;
        } 
    }

Copier après la connexion

Avantages : le processus normal et le processus d'erreur sont séparés, les programmeurs accordent plus d'attention au processus normal, le code est plus clair et c'est facile pour comprendre le code

L'idée centrale de la gestion des exceptions est l'EAFP

2.2 Lancement d'exceptions

Lors de l'écriture d'un programme, si une erreur se produit dans le programme, il est nécessaire d'en informer l'appelant des informations d'erreur
Ici, vous pouvez utiliser le mot-clé throw pour lancer un objet d'exception spécifié et informer l'appelant du message d'erreur.

Par exemple, écrivez une exception d'exécution

    public static void func2(int a) {
        if(a == 0) {
           //抛出的是一个指定的异常，最多的使用方式是，抛出一个自定义的异常
            throw new RuntimeException("a==0");
        }
    }
    public static void main(String[] args) {
        func2(0);
    }

Copier après la connexion

Causes des exceptions en Java et comment les gérer Remarque :

(1) throw doit être écrit dans le corps de la méthode
(2) Si une exception à la compilation est levée, l'utilisateur Il doit être géré, sinon il ne réussira pas la compilation
(3) Si une exception d'exécution est levée, elle n'a pas besoin d'être gérée et elle peut être directement transmise à la JVM pour le traitement
(4) Une fois qu'une exception se produit, ce qui suit Le code ne s'exécutera pas

2.3 异常的捕获

2.3.1 throws异常声明

Causes des exceptions en Java et comment les gérer

throws处在方法声明时参数列表之后，当方法中抛出编译时异常，用户不想处理该异常，
此时就可以借助throws将异常抛给方法的调用者来处理。
格式：
修饰符返回值类型方法名(参数列表) throws 异常类型 {
}

如果说方法内部抛出了多个异常，throws之后就必须跟多个异常类型，用逗号进行分隔

    public static void func2(int a) throws CloneNotSupportedException, FileNotFoundException {
        if(a == 0) {
            throw new CloneNotSupportedException("a==0");
        }
        if(a == 1) {
            throw new FileNotFoundException();
        }
    }

Copier après la connexion

如果抛出多个异常类型有父子关系，直接声明父类

    public static void func2(int a) throws Exception {
        if(a == 0) {
            throw new CloneNotSupportedException("a==0");
        }
        if(a == 1) {
            throw new FileNotFoundException();
        }
    }

Copier après la connexion

调用声明抛出异常的方法时，调用者必须对该异常进行处理，或者继续使用throws抛出

   public static void main(String[] args) throws FileNotFoundException, CloneNotSupportedException {
        func2(0);
    }

Copier après la connexion

2.3.2 try-catch捕获异常并处理

当程序抛出异常的时候，程序员通过try-each处理了异常

    public static void main(String[] args) {
        try {
            int[] array = null;
            System.out.println(array.length);
        }catch (NullPointerException e) {
            System.out.println("捕获到了一个空指针异常！");
        }
        System.out.println("其他程序！");
    }

Copier après la connexion

如果程序抛出异常，不处理异常，那就会交给JVM处理，JVM处理就会把程序立即终止

并且，即使用了try-each 也必须捕获一个对应的异常，如果不是对应异常，也会让JVM进行处理

Causes des exceptions en Java et comment les gérer

如果try抛出多个异常，就必须用多个catch进行捕获

这里注意，用多个catch进行捕获，不是同时进行捕获的，因为不可能同时抛不同的异常

    public static void main(String[] args) {
        try {
            int[] array = null;
            System.out.println(array.length);
        }catch (NullPointerException e) {
            System.out.println("捕获到了一个空指针异常！");
        }catch (ArithmeticException e) {
            System.out.println("捕获到了一个算术异常！");
        }
        System.out.println("其它代码逻辑！");
    }

Copier après la connexion

也可以简写一下

    public static void main(String[] args) {
        try {
            int[] array = null;
            System.out.println(array.length);
        }catch (NullPointerException  | ArithmeticException e) {
            System.out.println("捕获到了一个空指针或算术异常！");
        }
        System.out.println("其它代码逻辑！");
    }

Copier après la connexion

如果异常之间具有父子关系，那就必须子类异常在前，父类异常在后catch，不然会报错

    public static void main(String[] args) {
        try {
            int[] array = null;
            System.out.println(array.length);
        }catch (NullPointerException e) {
            System.out.println("捕获到了一个空指针异常！");
        }catch (Exception) {
            System.out.println("捕获到了一个算术异常！");
        }
        System.out.println("其它代码逻辑！");
    }

Copier après la connexion

2.3.3 finally

finally用来进行资源回收，不论程序正常运行还是退出，都需要回收资源
并且异常会引发程序的跳转，可能会导致有些语句执行不到

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        try {
            int[] array = null;
            System.out.println(array.length);
        }catch (NullPointerException e) {
            System.out.println("捕获到了一个空指针异常！");
        }catch (ArithmeticException e) {
            System.out.println("捕获到了一个算术异常！");
        }finally {
            scanner.close();
            System.out.println("进行资源关闭！");
        }
        System.out.println("其它代码逻辑！");
    }

Copier après la connexion

Causes des exceptions en Java et comment les gérer

如果不为空，那么finally还会被执行吗

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        try {
            int[] array = {1,2,3};
            System.out.println(array.length);
        }catch (NullPointerException e) {
            System.out.println("捕获到了一个空指针异常！");
        }catch (ArithmeticException e) {
            System.out.println("捕获到了一个算术异常！");
        }finally {
            scanner.close();
            System.out.println("进行资源关闭！");
        }
        System.out.println("其它代码逻辑！");
    }

Copier après la connexion

Causes des exceptions en Java et comment les gérer

所以，不管程序会不会抛出异常，finally都会执行

如果将资源写在try中会自动帮助，关掉资源的

    public static void main(String[] args) {
        try (Scanner scanner = new Scanner(System.in)) {
            int[] array = {1, 2, 3};
            System.out.println(array.length);
        } catch (NullPointerException e) {
            System.out.println("捕获到了一个空指针异常！");
        } catch (ArithmeticException e) {
            System.out.println("捕获到了一个算术异常！");
        } finally {
            System.out.println("进行资源关闭！");
        }
        System.out.println("其它代码逻辑！");
    }

Copier après la connexion

下面看这一段代码

    public static int func(int a) {
        try{
            if(a == 0) {
                throw  new ArithmeticException();
            }
            return a;
        } catch (ArithmeticException e) {
            System.out.println("算术异常！");
        } finally {
            return 20;
        }
    }

    public static void main(String[] args) {
        System.out.println(func(10));
    }

Copier après la connexion

Causes des exceptions en Java et comment les gérer

可以发现即使有return，finally也会被执行

总结一下：
throw抛出异常，throws声明异常
finally语句一定会执行

3.自定义异常类

虽然java中有很多异常类，但是在实际开发中所遇到的一些异常，不能完全表示，
所以这就需要我们自定义异常类

举一个例子

先自定义一个运行时异常

//自定义了一个运行时异常
public class MyException extends RuntimeException{
    public MyException() {

    }
    public MyException(String message) {
        super(message);
    }
}

Copier après la connexion

写一个类来捕获这个自定义异常

public class Test04 {
    public static void func(int a ) {
        throw new MyException("呵呵！");
    }

    public static void main(String[] args) {
        try {
            func(20);
        }catch (MyException myException) {
            myException.printStackTrace();
        }finally {
            System.out.println("sadasdasd");
        }

    }
}

Copier après la connexion

下面写一个用户登录的自定义异常类

class UserNameException extends RuntimeException {
    public UserNameException() {

    }
    public UserNameException(String message) {
        super(message);
    }
}
class PasswordException extends RuntimeException {

    public PasswordException() {
    }

    public PasswordException(String message) {
        super(message);
    }
}

Copier après la connexion

public class LogIn {
    private static String uName = "admin";
    private static String pword = "1111";

    public static void loginInfo(String userName, String password) {
        if ( !uName.equals(userName)) {
            throw new UserNameException("用户名错误！");
        }
        if ( !pword.equals(password)) {
            throw new RuntimeException("密码错误！");

        }
        System.out.println("登录成功！");
    }

    public static void main(String[] args) {
        try {
            loginInfo("admin","1111");
        } catch (UserNameException e) {
            e.printStackTrace();
        } catch (PasswordException e) {
            e.printStackTrace();
        }
    }
}

Copier après la connexion

注意：