Umgang mit Ausnahmetypen in Java

1. Beschreibung der Ausnahme

Bei der Ausführung des Programms tritt ein unerwartetes Ereignis auf, das verhindert, dass das Programm normal ausgeführt wird, wie vom Programmierer erwartet. Wenn eine Ausnahme auftritt, bleibt das Programm sich selbst überlassen und wird sofort beendet. In Java sind das Fehler, die beim Java-Kompilieren oder -Betrieb bzw. während des Betriebs auftreten.

Java bietet eine bessere Lösung: einen Ausnahmebehandlungsmechanismus.

Der Ausnahmebehandlungsmechanismus ermöglicht es dem Programm, Ausnahmen gezielt gemäß der voreingestellten Ausnahmebehandlungslogik des Codes zu behandeln, wenn eine Ausnahme auftritt, sodass das Programm zum Normalzustand zurückkehren und die Ausführung so weit wie möglich fortsetzen kann, während das Programm beibehalten wird Code klar.

Ausnahmen in Java können verursacht werden, wenn Anweisungen in einer Funktion ausgeführt werden, oder sie können manuell von Programmierern durch Throw-Anweisungen ausgelöst werden. Solange in einem Java-Programm eine Ausnahme auftritt, wird ein Ausnahmeobjekt des entsprechenden Typs verwendet Durch die Kapselung der Ausnahme versucht die JRE, einen Ausnahmehandler zu finden, der die Ausnahme behandelt.

• Ausnahme bezieht sich auf ungewöhnliche Situationen, die während des Betriebs auftreten.

• Verwenden von Klassen in Java, um abnormale Situationen zu beschreiben und Objekte zu kapseln.

• Eine Klasse, die ungewöhnliche Situationen beschreibt, wird zu einer Ausnahmeklasse.

• Trennen Sie normalen Code und Problembehandlungscode, um die Lesbarkeit zu verbessern.

• Tatsächlich sind Ausnahmen Java, die Probleme durch objektorientiertes Denken in Objekte kapseln und Ausnahmeklassen verwenden, um sie zu beschreiben.

2. Ausnahmesystem

Zwei Hauptkategorien:

• hrowable: Auslösbare Ausnahmen, unabhängig davon, ob es sich um einen Fehler oder eine Ausnahme handelt, sollten ausgelöst werden, wenn ein Problem auftritt, damit der Anrufer es erkennen und behandeln kann.

• Das Merkmal dieses Systems ist, dass Throwable und alle seine Unterklassen throwable sind.

Was genau bedeutet Wurffähigkeit? Wie spiegelt man die Wurffähigkeit wider?

• spiegelt sich in zwei Schlüsselwörtern wider.

• throws throw Alle Klassen und Objekte, die mit diesen beiden Schlüsselwörtern bedient werden können, sind werfend.

• Unterklasse 1 Generell nicht bearbeitbar. ————Fehler

• Eigenschaften: Es handelt sich um ein ernstes Problem, das von JVM ausgelöst wird. Wenn ein solches Problem auftritt, wird es im Allgemeinen nicht gezielt behandelt und das Programm wird direkt geändert.

• Unterklasse 2) kann damit umgehen. ——Ausnahme: Das Problem wird an den Anrufer weitergegeben, wer auch immer es an wen weiterleitet.

• Eigenschaften: Die Suffixnamen der Unterklassen werden alle mit dem Namen ihrer übergeordneten Klasse angehängt, was sehr gut lesbar ist!

Beispiel: Passen Sie beispielsweise eine Ausnahme mit einem negativen Index an und kapseln Sie sie mithilfe objektorientierten Denkens in ein Objekt.

• Hinweis: Wenn eine Klasse als Ausnahmeklasse bezeichnet wird, muss sie die Ausnahmeklasse erben. Weil nur Unterklassen des Ausnahmesystems auslösbar sind.

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. Ausnahmeklassifizierung:

Während der Kompilierung erkannte Ausnahmen sind auch Exception und ihre Unterklassen, mit Ausnahme der speziellen Unterklasse RuntimeException schlägt die Kompilierung ohne Verarbeitung fehl!

• Sobald ein solches Problem auftritt, hoffen wir, es zur Kompilierungszeit zu erkennen, damit dieses Problem entsprechend behandelt werden kann und solche Probleme gezielt angegangen werden können.

Unerkannte Ausnahmen während der Kompilierung (Laufzeitausnahmen): RuntimeException und ihre Unterklassen

• können verarbeitet werden oder nicht, und die Kompilierung kann erfolgreich sein und sie werden zur Laufzeit erkannt!

• Diese Art von Problem tritt auf, weil die Funktion nicht fortgesetzt werden kann und der Vorgang nicht ausgeführt werden kann. Es wird meist durch den Aufruf oder die Änderung des internen Status verursacht. Diese Art von Problem wird im Allgemeinen nicht behandelt, sondern direkt kompiliert und übergeben. Zur Laufzeit wird das Programm gezwungen, anzuhalten, wenn der Aufrufer ausgeführt wird, und der Aufrufer kann den Code korrigieren. Der Unterschied zwischen

throws und throw:

• throws wird in Funktionen verwendet ————Deklaration

• throw wird in Funktionen verwendet. Mehrere throws können durch Kommas getrennt werden. ————Throws

• throws löst eine Ausnahmeklasse aus und es können mehrere Ausnahmen ausgelöst werden.

• throw löst ein Ausnahmeobjekt aus.

4. Form der Ausnahmebehandlung erfassen

Dies ist eine Möglichkeit, Ausnahmen gezielt zu behandeln.

Format:

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

Beispiel

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

Hauptfunktion: Würfe sind nicht erforderlich, wir fangen Ausnahmen selbst ab

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

Ein Versuch entspricht mehreren Fängen:

• Bei mehreren Fängen der Fang der übergeordneten Klasse sollte unten platziert werden, sonst ist die Zusammenstellung leer.

5. Prinzipien der Ausnahmebehandlung

Wenn eine Ausnahme, die erkannt werden muss, innerhalb einer Funktion ausgelöst wird, muss sie in der Funktion deklariert werden, oder sie muss mit Try Catch innerhalb der Funktion abgefangen werden, andernfalls wird die Kompilierung ausgeführt scheitern.

Wenn die Funktion aufgerufen wird, die eine Ausnahme deklariert, versuchen Sie entweder Catch oder Throws, andernfalls schlägt die Kompilierung fehl.

Wann fangen? Wann wirft?

• Der funktionale Inhalt kann mithilfe von Catch gelöst werden.

• Wenn es nicht gelöst werden kann, teilen Sie es dem Anrufer mit Würfen mit, und der Anrufer wird es lösen.

一个功能如果抛出了多个异常，那么调用时，必须有对应的多个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("。。。。。");
                }
            }
    }

八、异常的注意事项：

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

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

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

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

Das obige ist der detaillierte Inhalt vonUmgang mit Ausnahmetypen in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!