Detaillierte Einführung in Ausnahmen in JAVA

1. Einführung in Ausnahmen

Ausnahme:

Ausnahme: Es ist abnormal. Ungewöhnliche Bedingungen, die auftreten, wenn das Programm ausgeführt wird. Tatsächlich handelt es sich um ein Problem im Programm. Dieses Problem wird nach objektorientierten Vorstellungen beschrieben und in Objekte gekapselt. Da das Problem über mehrere Attributinformationen verfügt, z. B. die Ursache des Problems, den Namen des Problems und die Beschreibung des Problems. Wenn Informationen mit mehreren Attributen angezeigt werden, besteht die bequemste Möglichkeit darin, die Informationen zu kapseln. Ausnahmen bilden Javas Objektkapselung von Problemen nach objektorientiertem Denken. Dies erleichtert die Bedienung und den Umgang mit Problemen.

Es gibt viele Arten von Problemen, wie zum Beispiel Eckmarkierungen außerhalb der Grenzen, Nullzeiger usw. Kategorisieren Sie diese Probleme einfach. Darüber hinaus haben diese Fragen einen gemeinsamen Inhalt, wie zum Beispiel: Jede Frage hat einen Namen sowie Informationen zur Problembeschreibung und den Ort des Problems, sodass sie kontinuierlich extrahiert werden können. Es entstand ein abnormales System.

Was ist das Ausnahmesystem in Java?

1. Alle abnormalen Klassen in Java erben von der Throwable-Klasse. Throwable umfasst hauptsächlich zwei Hauptkategorien, eine ist die Error-Klasse und die andere ist die Exception-Klasse

　

2. Die Error-Klasse umfasst Fehler der virtuellen Maschine Und Thread-Deadlock, sobald ein Fehler auftritt, hängt das Programm vollständig auf, was als Programmterminator bezeichnet wird;

3. Ausnahmeklasse, auch als „Ausnahme“ bekannt. Bezieht sich hauptsächlich auf Probleme mit Codierung, Umgebung und Benutzeroperationseingaben. Ausnahmen umfassen hauptsächlich zwei Kategorien , ungeprüfte Ausnahmen (RuntimeException) und geprüfte Ausnahmen (einige andere Ausnahmen)

　

4. RuntimeException-Ausnahmen umfassen hauptsächlich die folgenden vier Ausnahmen (tatsächlich gibt es viele andere Ausnahmen, die hier nicht aufgeführt sind): Nullzeiger-Ausnahme, Array-Index-Ausnahme außerhalb der Grenzen, Typkonvertierungsausnahme, Arithmetik Ausnahme

. RuntimeException-Ausnahmen werden automatisch von der Java Virtual Machine ausgelöst und erfasst

(auch wenn wir keine Ausnahmeerfassungsanweisung schreiben, wird während der Laufzeit ein Fehler ausgelöst!!) Auftretende Probleme liegen im Code selbst und sollten logisch gelöst und der Code verbessert werden. 　

5. Auf Ausnahmen prüfen Es gibt verschiedene Gründe für diese Ausnahme, z. B. weil die Datei nicht vorhanden ist oder ein Verbindungsfehler vorliegt. Im Gegensatz zu seinem „Bruder“ RuntimeException müssen wir manuell Capture-Anweisungen in den Code einfügen, um diese Ausnahme zu behandeln

Dies ist auch das Hauptausnahmeobjekt, das wir beim Erlernen von Java-Ausnahmeanweisungen behandeln.

　

2. try-catch-finally-Anweisung

---

(1) try-Block:

ist für das Abfangen von Ausnahmen verantwortlich

, einmal versuchen Wenn eine Ausnahme gefunden wird, wird die Kontrolle über das Programm an den Ausnahmehandler im Catch-Block übergeben.

　[try-Anweisungsblock kann nicht unabhängig existieren und muss mit dem Catch- oder Final-Block koexistieren]

(2) Catch-Block: Wie geht man damit um? Geben Sie beispielsweise Warnungen aus: Eingabeaufforderungen, überprüfen Sie die Konfiguration, die Netzwerkverbindung, protokollieren Sie Fehler usw.

. Nach der Ausführung des Catch-Blocks springt das Programm aus dem Catch-Block und führt weiterhin den folgenden Code aus.

【Hinweise zum Schreiben von Catch-Blöcken: Ausnahmeklassen, die von mehreren Catch-Blöcken behandelt werden, sollten so behandelt werden, dass zuerst die Unterklasse und dann die übergeordnete Klasse abgefangen wird, da Ausnahmen [in der Nähe behandelt] werden (von das Obige von unten).

】

(3) schließlich: Endlich ausgeführter Code

, der zum Schließen und Freigeben von Ressourcen verwendet wird.

========================================== == ==========================

Das Syntaxformat ist wie folgt:

当异常出现时，程序将终止执行，交由异常处理程序（抛出提醒或记录日志等），异常代码块外代码正常执行。 try会抛出很多种类型的异常，由多个catch块捕获多钟错误。

多重异常处理代码块顺序问题：先子类再父类（顺序不对编译器会提醒错误），finally语句块处理最终将要执行的代码。

=======================================================================

接下来，我们用实例来巩固try-catch语句吧~

先看例子：

 1 package com.hysum.test; 2  3 public class TryCatchTest { 4     /** 5      * divider:除数 6      * result:结果 7      * try-catch捕获while循环 8      * 每次循环，divider减一，result=result+100/divider 9      * 如果：捕获异常，打印输出“异常抛出了”，返回-110      * 否则：返回result11      * @return12      */13     public int test1(){14         int divider=10;15         int result=100;16         try{17             while(divider>-1){18                 divider--;19                 result=result+100/divider;20             }21             return result;22         }catch(Exception e){23             e.printStackTrace();24             System.out.println("异常抛出了！！");25             return -1;26         }27     }28     public static void main(String[] args) {29         // TODO Auto-generated method stub30         TryCatchTest t1=new TryCatchTest();31         System.out.println("test1方法执行完毕！result的值为："+t1.test1());32     }33     34 }

运行结果：

结果分析：结果中的红色字抛出的异常信息是由e.printStackTrace()来输出的，它说明了这里我们抛出的异常类型是算数异常，后面还跟着原因：by zero（由0造成的算数异常），下面两行at表明了造成此异常的代码具体位置。

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

在上面例子中再加上一个test2()方法来测试finally语句的执行状况：

 1     /** 2      * divider:除数 3      * result:结果 4      * try-catch捕获while循环 5      * 每次循环，divider减一，result=result+100/divider 6      * 如果：捕获异常，打印输出“异常抛出了”，返回result=999 7      * 否则：返回result 8      * finally：打印输出“这是finally，哈哈哈！！”同时打印输出result 9      * @return10      */11     public int test2(){12         int divider=10;13         int result=100;14         try{15             while(divider>-1){16                 divider--;17                 result=result+100/divider;18             }19             return result;20         }catch(Exception e){21             e.printStackTrace();22             System.out.println("异常抛出了！！");23             return result=999;24         }finally{25             System.out.println("这是finally，哈哈哈！！");26             System.out.println("result的值为："+result);27         }28         29     }30     31     32     33     public static void main(String[] args) {34         // TODO Auto-generated method stub35         TryCatchTest t1=new TryCatchTest();36         //System.out.println("test1方法执行完毕！result的值为："+t1.test1());37         t1.test2();38         System.out.println("test2方法执行完毕！");39     }

运行结果：

结果分析：我们可以从结果看出，finally语句块是在try块和catch块语句执行之后最后执行的。finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，仍然是之前保存的值），所以函数返回值是在finally执行前确定的；

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

这里有个有趣的问题，如果把上述中的test2方法中的finally语句块中加上return，编译器就会提示警告：finally block does not complete normally 

  public int test2(){ 
          int divider=10; 
          int result=100; 
          try{ 
              while(divider>-1){ 
                  divider--; 
                  result=result+100/divider; 
              } 
              return result;10         }catch(Exception e){
              e.printStackTrace();
              System.out.println("异常抛出了！！");
              return result=999;14         }finally{
              System.out.println("这是finally，哈哈哈！！");
              System.out.println("result的值为："+result);
              return result;//编译器警告18         }
          
      }

分析问题: finally块中的return语句可能会覆盖try块、catch块中的return语句;如果finally块中包含了return语句，即使前面的catch块重新抛出了异常，则调用该方法的语句也不会获得catch块重新抛出的异常，而是会得到finally块的返回值，并且不会捕获异常。

解决问题：面对上述情况，其实更合理的做法是，既不在try block内部中使用return语句，也不在finally内部使用 return语句，而应该在 finally 语句之后使用return来表示函数的结束和返回。如：

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

 总结：

　　1、不管有木有出现异常或者try和catch中有返回值return，finally块中代码都会执行；

　　2、finally中最好不要包含return，否则程序会提前退出，返回会覆盖try或catch中保存的返回值。

　　3.  e.printStackTrace()可以输出异常信息。

　　4.  return值为-1为抛出异常的习惯写法。

　　5.  如果方法中try,catch,finally中没有返回语句，则会调用这三个语句块之外的return结果。

　　6.  finally 在try中的return之后 在返回主调函数之前执行。

---

三、throw和throws关键字

java中的异常抛出通常使用throw和throws关键字来实现。

throw ----将产生的异常抛出，是抛出异常的一个动作。

一般会用于程序出现某种逻辑时程序员主动抛出某种特定类型的异常。如：
　　语法：throw (异常对象)，如：

1 public static void main(String[] args) { 
2     String s = "abc"; 
3     if(s.equals("abc")) { 
4       throw new NumberFormatException(); 
5     } else { 
6       System.out.println(s); 
7     } 
8     //function(); 9 }

运行结果：

Exception in thread "main" java.lang.NumberFormatException
at test.ExceptionTest.main(ExceptionTest.java:67)

throws----声明将要抛出何种类型的异常（声明）。

语法格式：

1 public void 方法名（参数列表）2    throws 异常列表{3 //调用会抛出异常的方法或者：4 throw new Exception（）；5 }

当某个方法可能会抛出某种异常时用于throws 声明可能抛出的异常，然后交给上层调用它的方法程序处理。如：

 1 public static void function() throws NumberFormatException{ 
 2     String s = "abc"; 
 3     System.out.println(Double.parseDouble(s)); 
 4   } 
 5      6   public static void main(String[] args) { 
 7     try { 
 8       function(); 
 9     } catch (NumberFormatException e) { 
10       System.err.println("非数据类型不能转换。"); 
11       //e.printStackTrace(); 12     } 
13 }

throw与throws的比较
1、throws出现在方法函数头；而throw出现在函数体。
2、throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常对象。
3、两者都是消极处理异常的方式（这里的消极并不是说这种方式不好），只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。

来看个例子：

throws e1,e2,e3只是告诉程序这个方法可能会抛出这些异常，方法的调用者可能要处理这些异常，而这些异常e1，e2，e3可能是该函数体产生的。
throw则是明确了这个地方要抛出这个异常。如：

 1 void doA(int a) throws (Exception1,Exception2,Exception3){ 2       try{ 3          ...... 4   5       }catch(Exception1 e){ 6        throw e; 7       }catch(Exception2 e){ 8        System.out.println("出错了！"); 9       }10       if(a!=b)11        throw new Exception3("自定义异常");12 }

Analyse:
1. Im Codeblock können drei Ausnahmen auftreten (Ausnahme1, Ausnahme2, Ausnahme3).
2. Wenn eine Ausnahme1-Ausnahme auftritt, wird sie nach dem Abfangen ausgelöst und vom Aufrufer der Methode behandelt.
3. Wenn eine Exception2-Ausnahme auftritt, behandelt die Methode diese selbst (d. h. System.out.println("Ein Fehler ist aufgetreten!");). Diese Methode löst also nicht mehr die Ausnahme Exception2, void, aus Es besteht keine Notwendigkeit, Exception2 in doA() zu schreiben, was Exception1, Exception3 auslöst. Weil es mit der Try-Catch-Anweisung erfasst und verarbeitet wurde.
4.Exception3-Ausnahme ist ein bestimmter Logikfehler in dieser Methode Der Programmierer hat ihn selbst behandeltWenn bei diesem Logikfehler die Ausnahme Exception3 ausgelöst wird, wird die Methode aufgerufen Der Operator sollte auch diese Ausnahme behandeln. Hier kommt eine benutzerdefinierte Ausnahme zum Einsatz, die im Folgenden erläutert wird.

>>>>>>>>>>>>>>>>>>> ;>> ;>>>>>>>>>>>>>>>>>>>>>>> ;>> ;

Bei der Verwendung der Schlüsselwörter throw und throws müssen Sie auf die folgenden Punkte achten:

1. Die Ausnahmeliste von throws kann eine oder mehrere Ausnahmen auslösen Ausnahmen können ausgelöst werden. Jeder Ausnahmetyp wird durch Kommas getrennt.

2. Rufen Sie die Methode auf, die eine Ausnahme im Methodenkörper auslöst, oder werfen Sie zuerst eine Ausnahme aus: Verwenden Sie „throw new Exception ()“ und schreiben Sie „throw“. Methodenkörper, der die Aktion „Auslösen einer Ausnahme“ angibt.

3. Wenn eine Methode eine Methode aufruft, die eine Ausnahme auslöst, müssen Sie eine try-catch-Anweisung hinzufügen, um zu versuchen, diese Ausnahme abzufangen, oder eine Anweisung hinzufügen, um die Ausnahme an den übergeordneten Aufrufer auszulösen ;>>>>>>>>>>>>>>>>>>>>>>>> ;>>

Benutzerdefinierte Ausnahme

Warum benutzerdefinierte Ausnahmen verwenden, was sind das? die

Vorteile

? 1. Wenn wir arbeiten, wird das Projekt in Modulen oder Funktionen entwickelt. Grundsätzlich entwickeln Sie kein gesamtes Projekt selbst. Unified die Art und Weise, äußere Anomalien anzuzeigen .

2. Wenn wir auf bestimmte Überprüfungen oder Probleme stoßen, müssen wir die aktuelle Anfrage direkt beenden. Zu diesem Zeitpunkt können wir sie beenden, indem wir eine benutzerdefinierte Ausnahme auslösen Wenn im Projekt eine neuere Version von SpringMVC verwendet wird, gibt es eine Controller-Erweiterungsklasse. Sie können über die Annotation @ControllerAdvice eine Controller-Erweiterungsklasse schreiben, um benutzerdefinierte Ausnahmen abzufangen und dem Frontend mit entsprechenden Informationen zu antworten

. 3. Benutzerdefinierte Ausnahmen können Ausnahmen auslösen, wenn bestimmte spezielle Geschäftslogik in unserem Projekt, wie z. B. „neutral“.equals(sex), Wir müssen eine auslösen Ausnahme, wenn das Geschlecht gleich neutral ist, aber Java hat diese Ausnahme nicht. Einige Fehler im System entsprechen der Java-Syntax, entsprechen jedoch nicht der Geschäftslogik unseres Projekts.

4. Verwenden Sie benutzerdefinierte Ausnahmen im Zusammenhang mit der Ausnahmevererbung, um verarbeitete Ausnahmeinformationen auszulösen. Sie können die zugrunde liegende Ausnahme ausblenden, was sicherer und die Ausnahmeinformationen intuitiver ist. Benutzerdefinierte Ausnahmen können die Informationen auslösen, die wir auslösen möchten. Anhand des Ausnahmenamens können wir erkennen, wo sich die Ausnahme befindet, und das Programm entsprechend der Ausnahme ändern zeitnahe Informationen. Im Fall einer NullPointException können wir beispielsweise die Information „xxx ist null“ auslösen, um den Ausnahmeort zu lokalisieren, ohne Stapelinformationen auszugeben.

Nachdem wir darüber gesprochen haben, warum Sie benutzerdefinierte Ausnahmen verwenden sollten und welche Vorteile sie haben, werfen wir einen Blick auf die

Probleme

von benutzerdefinierten Ausnahmen: Natürlich können wir nicht erwarten, dass die JVM (Java Virtual Machine) automatisch eine benutzerdefinierte Ausnahme auslöst, und wir können auch nicht erwarten, dass die JVM eine benutzerdefinierte Ausnahme automatisch behandelt. Die Arbeit des Erkennens von Ausnahmen, des Auslösens von Ausnahmen und der Behandlung von Ausnahmen muss vom Programmierer selbst mithilfe des Ausnahmebehandlungsmechanismus im Code erledigt werden. Dies erhöht entsprechend die Entwicklungskosten und den Arbeitsaufwand. Wenn das Projekt dies nicht benötigt, müssen nicht unbedingt benutzerdefinierte Ausnahmen verwendet werden. Sie müssen in der Lage sein, dies selbst abzuwägen.

Schließlich sehen wir uns an, wie

benutzerdefinierte

Ausnahmen verwendet werden: In Java können Sie Ausnahmen anpassen. Beim Schreiben eigener Ausnahmeklassen sind einige Dinge zu beachten.

Alle Ausnahmen müssen Unterklassen von Throwable sein.

如果希望写一个检查性异常类，则需要继承 Exception 类。

如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。

可以像下面这样定义自己的异常类：

class MyException extends Exception{ }

 

我们来看一个实例：

 1 package com.hysum.test; 2  3 public class MyException extends Exception { 4      /** 5      * 错误编码 6      */ 7     private String errorCode; 8  9    10     public MyException(){}11     12     /**13      * 构造一个基本异常.14      *15      * @param message16      *        信息描述17      */18     public MyException(String message)19     {20         super(message);21     }22 23    24 25     public String getErrorCode() {26         return errorCode;27     }28 29     public void setErrorCode(String errorCode) {30         this.errorCode = errorCode;31     }32 33     34 }

使用自定义异常抛出异常信息：

 1 package com.hysum.test; 2  3 public class Main { 4  5     public static void main(String[] args) { 6         // TODO Auto-generated method stub 7         String[] sexs = {"男性","女性","中性"}; 8                   for(int i = 0; i < sexs.length; i++){ 9                       if("中性".equals(sexs[i])){10                           try {11                             throw new MyException("不存在中性的人！");12                         } catch (MyException e) {13                             // TODO Auto-generated catch block14                             e.printStackTrace();15                         }16                      }else{17                          System.out.println(sexs[i]);18                      }19                 } 
20     }21 22 }

运行结果：

就是这么简单，可以根据实际业务需求去抛出相应的自定义异常。

---

四、java中的异常链

异常需要封装，但是仅仅封装还是不够的，还需要传递异常。

异常链是一种面向对象编程技术，指将捕获的异常包装进一个新的异常中并重新抛出的异常处理方式。原异常被保存为新异常的一个属性（比如cause）。这样做的意义是一个方法应该抛出定义在相同的抽象层次上的异常，但不会丢弃更低层次的信息。

我可以这样理解异常链：

把捕获的异常包装成新的异常，在新异常里添加原始的异常，并将新异常抛出，它们就像是链式反应一样，一个导致（cause）另一个。这样在最后的顶层抛出的异常信息就包括了最底层的异常信息。

》场景

比如我们的JEE项目一般都又三层：持久层、逻辑层、展现层，持久层负责与数据库交互，逻辑层负责业务逻辑的实现，展现层负责UI数据的处理。

有这样一个模块：用户第一次访问的时候，需要持久层从user.xml中读取数据，如果该文件不存在则提示用户创建之，那问题就来了：如果我们直接把持久层的异常FileNotFoundException抛弃掉，逻辑层根本无从得知发生任何事情，也就不能为展现层提供一个友好的处理结果，最终倒霉的就是展现层：没有办法提供异常信息，只能告诉用户“出错了，我也不知道出了什么错了”—毫无友好性而言。

正确的做法是先封装，然后传递，过程如下：

　1.把FileNotFoundException封装为MyException。

2.抛出到逻辑层，逻辑层根据异常代码（或者自定义的异常类型）确定后续处理逻辑，然后抛出到展现层。

3.展现层自行确定展现什么，如果管理员则可以展现低层级的异常，如果是普通用户则展示封装后的异常。

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

》示例

 1 package com.hysum.test; 2  3 public class Main { 4     public void test1() throws RuntimeException{ 5         String[] sexs = {"男性","女性","中性"}; 6         for(int i = 0; i < sexs.length; i++){ 7             if("中性".equals(sexs[i])){ 8                 try { 9                     throw new MyException("不存在中性的人！");10                 } catch (MyException e) {11                     // TODO Auto-generated catch block12                     e.printStackTrace();13                     RuntimeException rte=new RuntimeException(e);//包装成RuntimeException异常14                     //rte.initCause(e);15                     throw rte;//抛出包装后的新的异常16                 }17            }else{18                System.out.println(sexs[i]);19            }20       } 
21     }22     public static void main(String[] args) {23         // TODO Auto-generated method stub24         Main m =new Main();25         26         try{27         m.test1();28         }catch (Exception e){29             e.printStackTrace();30             e.getCause();//获得原始异常31         }32         33     }34 35 }

Ausführungsergebnisse:

Ergebnisanalyse: Wir können sehen, dass die Konsole zuerst die ursprüngliche Ausnahme ausgibt, die von e.getCause(); ausgegeben wird, und dann e.printStackTrace(), hier sehen Sie Verursacht durch: Die ursprüngliche Ausnahme stimmt mit der Ausgabe von e.getCause() überein. Dies bildet eine abnormale Kette. Die Funktion von initCause() besteht darin, die ursprüngliche Ausnahme einzuschließen. Wenn Sie wissen möchten, welche Ausnahme auf der untersten Ebene aufgetreten ist, können Sie die ursprüngliche Ausnahme durch Aufrufen von getCause() abrufen.

>>>>>>>>>>>>>>>>>>> ;>> ;>>>>>>>>>>>>>>>>>>>>>>> ;>> ;

》Es wird empfohlen,

Ausnahmen zu kapseln und zu übergeben. Wenn wir das System entwickeln, sollten wir keine Ausnahmen „verschlucken“ oder „nackte“ Ausnahmen werfen werden ausgelöst, nachdem sie gekapselt oder durch eine Ausnahmekette geleitet wurden, um das System robuster und benutzerfreundlicher zu machen.

---

5. Fazit

Das Wissen über die Java-Ausnahmebehandlung ist kompliziert und etwas schwer zu verstehen. Ich habe die folgenden Punkte für Sie zusammengefasst, wenn Sie die Java-Ausnahmebehandlung verwenden:

Gute Codierungsgewohnheiten:

1. Verwenden Sie beim Umgang mit Laufzeitausnahmen Logik, um die Try-Catch-Verarbeitung angemessen zu vermeiden und zu unterstützen

2 . Nach mehreren Catch-Blöcken können Sie einen Catch (Ausnahme) hinzufügen, um Ausnahmen zu behandeln, die möglicherweise übersehen werden

3 Bei unsicherem Code können Sie auch Try-Catch hinzufügen, um potenzielle Ausnahmen zu behandeln

4. Versuchen Sie, Ausnahmen so oft wie möglich zu behandeln. Rufen Sie einfach printStackTrace() auf, um

zu drucken. 5. Wie mit Ausnahmen umgegangen wird, sollte entsprechend den unterschiedlichen Geschäftsanforderungen und Ausnahmetypen entschieden werden 6. Versuchen Sie, „finally“-Anweisungsblöcke hinzuzufügen, um belegte Ressourcen freizugeben