Ursachen für Ausnahmen in Java und wie man damit umgeht

Eine Ausnahme in Java, auch als Ausnahme bekannt, ist ein Ereignis, das während der Ausführung eines Programms auftritt und die Ausführung unterbricht Normaler Befehlsablauf des Programms. Um laufende Fehler im Programm zeitnah und effektiv behandeln zu können, müssen Ausnahmeklassen verwendet werden.

1. Ursachen und Klassifizierung von Ausnahmen

1.1 Gründe für Ausnahmen

at Es gibt Drei Hauptgründe für Ausnahmen in Java:

(1) Ausnahmen, die durch Fehler beim Schreiben von Programmcode verursacht werden, z. B. Array außerhalb der Grenzen, null Zeiger Ausnahmen usw. Diese Art von Ausnahme wird als ungeprüfte Ausnahme bezeichnet. Im Allgemeinen müssen diese Ausnahmen in der Klasse behandelt werden. Ausnahme

(3) Ausnahmen, die manuell generiert werden Die Throw-Anweisung (Throw-Ausnahme) wird als geprüfte Ausnahme bezeichnet und im Allgemeinen verwendet, um dem Methodenaufrufer einige notwendige Informationen zu geben.

(1) Throwable: Es ist die oberste Klasse des Ausnahmesystems, das zwei wichtige Unterklassen ableitet, Error und Exception

                      und Fehler und Ausnahme  zwei Unterklassen bzw. Fehler und Ausnahmen.

Der Unterschied besteht in der ungeprüften Ausnahme und der geprüften Ausnahme.

(2) Die Exception-Klasse wird für Ausnahmen verwendet, die in Benutzerprogrammen auftreten können. Sie ist auch eine Klasse, die zum Erstellen benutzerdefinierter Ausnahmetypklassen verwendet wird.

(3) Fehler definiert Ausnahmen, von denen unter normalen Umständen nicht zu erwarten ist, dass sie vom Programm abgefangen werden. Ausnahmen vom Typ „Error“ werden von der Java-Laufzeit verwendet, um Fehler anzuzeigen, die das Laufzeitsystem selbst betreffen. Ein Stapelüberlauf ist ein Beispiel für diesen Fehler.

Ausnahmen können während der Kompilierung oder während der Ausführung des Programms auftreten und können unterteilt werden in: # 🎜 🎜#

Laufzeitausnahmen sind Ausnahmen der RuntimeException-Klasse und ihrer Unterklassen, z. B. NullPointerException, IndexOutOfBoundsException usw. Diese Ausnahmen sind ungeprüfte Ausnahmen. Sie können sie im Programm erfassen oder nicht damit umgehen. Diese Ausnahmen werden im Allgemeinen durch Programmlogikfehler verursacht, und das Programm sollte versuchen, das Auftreten solcher Ausnahmen aus logischer Sicht zu vermeiden.

Zum Beispiel:

Kompilierungszeitausnahme is Bezieht sich auf andere Ausnahmen als RuntimeException, die zur Exception-Klasse und ihren Unterklassen gehören. Aus Sicht der Programmsyntax handelt es sich um eine Ausnahme, die behandelt werden muss. Wenn sie nicht behandelt wird, wird das Programm nicht kompiliert. Wie IOException, ClassNotFoundException usw. und benutzerdefinierte Ausnahmeausnahmen. Im Allgemeinen werden keine benutzerdefinierten geprüften Ausnahmen verwendet.

Zum Beispiel

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();
    }
}

2. Ausnahmebehandlung#🎜🎜 #2.1 Defensive Programmierung

Fehler liegen objektiv im Code vor. Daher muss der Programmierer schnell benachrichtigt werden, wenn ein Problem im Programm auftritt.

Da Es gibt zwei Benachrichtigungsmöglichkeiten:

(1) LBYL führt vor dem Betrieb eine ausreichende Inspektion durch

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;
        }
    }

Nachteile: normaler Prozess und Fehler Die Codes für den Verarbeitungsablauf sind gemischt und die Gesamtreihenfolge der Codes ist nicht klar.

(2) EAFP arbeitet zuerst und stößt auf Probleme, bevor es sich darum kümmert

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;
        } 
    }

Vorteile: normaler Prozess und Fehler Der Prozess ist getrennt. Der Code ist klarer und leichter zu verstehen. 2.2 Ausnahmen auslösen

# 🎜🎜#

Wenn beim Schreiben eines Programms ein Fehler im Programm auftritt, wird dies Die Fehlerinformationen müssen dem Anrufer mitgeteilt werden

Hier Mit dem Schlüsselwort throw können Sie ein bestimmtes Ausnahmeobjekt auslösen und den Aufrufer über die Fehlerinformationen informieren.

Schreiben Sie beispielsweise eine Laufzeitausnahme

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

Hinweis: # 🎜🎜#

(1) throw muss in den Methodenkörper geschrieben werden

(2) Wenn eine Ausnahme zur Kompilierungszeit ausgelöst wird , der Benutzer Es muss verarbeitet werden, sonst wird die Kompilierung nicht bestanden

(3) Wenn eine Laufzeitausnahme vorliegt ausgelöst wird, können Sie es nicht verarbeiten. Überlassen Sie die Verarbeitung einfach der JVM.

(4) Sobald eine Ausnahme auftritt, wird der folgende Code nicht ausgeführt # 🎜🎜#

2.3 异常的捕获

2.3.1 throws异常声明

 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();
        }
    }

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

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

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

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

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("其他程序！");
    }

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

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

 如果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("其它代码逻辑！");
    }

也可以简写一下

    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("其它代码逻辑！");
    }

如果异常之间具有父子关系，那就必须子类异常在前，父类异常在后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("其它代码逻辑！");
    }

---

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("其它代码逻辑！");
    }

如果不为空，那么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("其它代码逻辑！");
    }

所以，不管程序会不会抛出异常，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("其它代码逻辑！");
    }

下面看这一段代码

    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));
    }

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

总结一下：

throw抛出异常，throws声明异常

finally语句一定会执行

3.自定义异常类

虽然java中有很多异常类，但是在实际开发中所遇到的一些异常，不能完全表示，

所以这就需要我们自定义异常类

举一个例子

先自定义一个运行时异常

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

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

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

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");
        }

    }
}

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

class UserNameException extends RuntimeException {
    public UserNameException() {

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

    public PasswordException() {
    }

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

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();
        }
    }
}

注意：

自定义异常默认会继承 Exception 或者 RuntimeException  

继承于 Exception 的异常默认是受查异常  

继承于 RuntimeException 的异常默认是非受查异常  

Das obige ist der detaillierte Inhalt vonUrsachen für Ausnahmen in Java und wie man damit umgeht. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!