Beispielanalyse des Java-Ausnahmebehandlungsmechanismus

Das zugrunde liegende Prinzip des Ausnahmebehandlungsmechanismus

• Wenn beim Ausführen einer Methode eine Ausnahme gesendet wird, generiert diese Methode ein Objekt, das die Ausnahme darstellt, stoppt den aktuellen Ausführungspfad und sendet die Ausnahme an jre.

• Ausnahme abfangen: Nachdem jre die Ausnahme erhalten hat, täuscht es den entsprechenden Code vor, um die Ausnahme zu behandeln. jre durchsucht den Aufrufstapel der Methode und verfolgt die Methode zurück, die die Ausnahme generiert hat, bis der entsprechende Ausnahmebehandlungscode gefunden wird.

Ausnahmevererbungsdiagramm

Oak, jetzt, da wir wissen, was die Definition einer Ausnahme ist, wie sollten wir dann Ausnahmen abfangen und sie dann behandeln?

Ausnahmebehandlung

1. Schauen wir uns zunächst einen Teil des Codes an:

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对象，节省资源
        }
    }

}

Code-Erklärung:

Der obige Code enthält eine Try-Catch-finally-Struktur ihre jeweiligen Funktionen?

try: Wir verwenden try, um Code einzubinden, der Ausnahmen verursachen kann.

catch: Solange eine Ausnahme auftritt, wenn der Code im Try-Codeblock ausgeführt wird, wird Catch eingegeben, um die Ausnahme zu erfassen.

finally: Egal wie Der vorherige Code wird ausgeführt. Der letzte Codeblock wird ausgeführt! !

Beispiel für laufende Ergebnisse:

Normale Zeit:

Abnormale Zeit:

Wenn die Dividende 0 ist, wird eine Ausnahme ausgelöst und zur Erfassung in Catah eingegeben, aber unabhängig davon, ob eine Ausnahme vorliegt, wird die Das Programm in wird schließlich ausgeführt. Ausgabe: Das Programm endet, die Ressource wurde geschlossen und kann gerne wieder verwendet werden Im obigen Code kann es beispielsweise eine Dividende von 0 geben. Ausnahme: Es kann auch eine Eingabeausnahme geben, wenn Zeichen zur Berechnung eingegeben werden, oder es kann eine Ausnahme bei der Zahlenformatierung usw. geben , können wir Multi-Catch verwenden, um die Ausnahme abzufangen:

Oder nehmen Sie den obigen Code als Beispiel:

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对象，节省资源
        }
    }

}

Wenn die Eingabe nicht erfolgt. Wenn es um Zahlen geht:

Auf diese Weise können wir sehen, dass dies der Fall ist wurde im ersten Catch gefangen

Drei, throws deklariert eine Ausnahme/throw wirft eine Ausnahme:

Angenommen, ich definiere eine Methode, um die Methode zu informieren. Möglicherweise wird eine Art Ausnahme (deklarierte Ausnahme) gesendet, und der Aufrufer muss die Ausnahme beim Aufruf behandeln die Methode. 🔜 Geschlecht Wenn die Eingabe falsch ist:

Hinweis: Bei mehreren Ausnahmen wird die erste ausgelöst, die auftritt.

4. Angepasste Ausnahmen:

Wenn die Laufzeitausnahme-Unterklasse von RuntimeException unsere Anforderungen nicht erfüllen kann, können wir auch die Laufzeitausnahme anpassen und benutzerdefinierte Ausnahmeinformationen auslösen, um unsere Anforderungen zu erfüllen. Hinweis: Benutzerdefinierte Laufzeitausnahmen müssen RuntimeException erben! ! !

Benutzerdefinierte Ausnahmeklasse:

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("性别输入有误");
        }

    }
}

Studenteninformationsklasse:

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

Testklasse:

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

Der Code in diesem Teil stimmt mit dem dritten Teil oben überein.

5. Häufige Anomalien

Das obige ist der detaillierte Inhalt vonBeispielanalyse des Java-Ausnahmebehandlungsmechanismus. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!