Was ist eine Ausnahme in Java?

Was ist eine Ausnahme?

Schlecht strukturierter Code wird nicht ausgeführt, das ist die Grundphilosophie von Java.

Der ideale Zeitpunkt, Fehler zu finden, ist die Kompilierungszeit. Allerdings kann der Compiler nicht alle Fehler finden und die verbleibenden Probleme müssen während der Ausführung des Programms gelöst werden. Dies setzt voraus, dass der Fehler entsprechende Informationen an einen bestimmten Empfänger zur Verarbeitung auf irgendeine Weise weiterleiten kann.

Der Zweck der Ausnahmebehandlung in Java besteht darin, die Generierung großer, zuverlässiger Programme durch die Verwendung einer kleinen Codemenge zu vereinfachen. Auf diese Weise gibt es keine unbehandelten Fehler in Ihrer Anwendung und bringt auch ein Offensichtliches mit sich Vorteil: geringere Komplexität des Fehlerbehandlungscodes.

Abnormal bedeutet laut wörtlicher Bedeutung unerwartet. Um es auf Codeebene zu verstehen: Es verhindert, dass die aktuelle Methode oder der aktuelle Bereich weiterhin ausgeführt wird. Ausnahmen sind Ereignisse, die dazu führen, dass ein Programm bei der beabsichtigten Ausführung fehlschlägt. Es gibt drei Arten von Ausnahmen: geprüfte Ausnahmen, Fehler und Laufzeitausnahmen.

In Java werden Ausnahmen als Objekte behandelt und ihre Basisklasse ist Throwable.

Ausnahmetypen in Java

Java leitet Ausnahme und Fehler direkt von Throwable ab. Ausnahme ist der Grundtyp, der ausgelöst werden kann. Ausnahmen vom Ausnahmetyp können in Java-Klassenbibliotheken, -Methoden und bei Laufzeitfehlern ausgelöst werden. „Exception“ stellt eine behebbare Ausnahme dar, die vom Compiler abgefangen werden kann. „Error“ stellt einen Kompilierungs- und Systemfehler dar, der darauf hinweist, dass während der Ausführung des Systems ein schwerwiegender Fehler aufgetreten ist auf der JVM-Ebene. Dieser Fehler führt dazu, dass das Programm die Ausführung beendet. Ausnahmen werden in geprüfte Ausnahmen und Laufzeitausnahmen unterteilt.

Das Strukturhierarchiediagramm der Ausnahmeklasse lautet wie folgt:

Typische RuntimeException (Laufzeitausnahme) umfasst NullPointerException, ClassCastException (Typkonvertierungsausnahme) und IndexOutOfBoundsException (Ausnahme außerhalb der Grenzen), IllegalArgumentException (Unzulässige Parameterausnahme), ArrayStoreException (Arithmetikausnahme), BufferOverflowException (Pufferüberlaufausnahme) usw.;

Non-RuntimeException (geprüfte Ausnahmen) umfassen IOException, SQLException, InterruptedException (unterbrochene Ausnahme – wenn der aufrufende Thread in den Ruhezustand wechselt), NumberFormatException (Ausnahme bei der Zahlenformatierung) usw.

Je nach Compiler-Überprüfungsmethode können Ausnahmen in geprüfte Ausnahmen (CheckedException) und ungeprüfte Ausnahmen (UncheckedException) unterteilt werden. Die Kombination aus Error und RuntimeException heißt UncheckedException. Sie wird so genannt, weil der Compiler nicht prüft, ob die Methode diese beiden Ausnahmetypen behandelt oder auslöst. Daher wird kein Fehler gemeldet, wenn dieser Ausnahmetyp während der Kompilierung auftritt ist virtuell Die Maschine stellt Verarbeitungsmethoden bereit. Mit Ausnahme der beiden Arten von Ausnahmen „Error“ und „RuntimeException“ werden andere Ausnahmen als „Geprüfte Ausnahmen“ bezeichnet.

Wie Java mit Ausnahmen umgeht

1 🎜>Bei Ausnahmen vom geprüften Typ müssen wir diese entweder behandeln oder Würfe im Methodenheader verwenden.

public static void createFile() throws IOException{
    File file = new File("C:/test.txt");
    if(!file.exists()){
            file.createNewFile();
    }
}
public static void main(String[] args) {
    try {
        createFile();
    } catch (IOException ex) {
        // handle exception here
    }
}

Ein paar Punkte, die Sie zum Fang beachten sollten:

1). Der Ausnahmetyp des Parameters muss die Throwable-Klasse oder ihre Unterklasse sein.

2) Bei Catch-Anweisungen von oben nach unten müssen die Parametertypen in der Reihenfolge von der Unterklasse zur übergeordneten Klasse vorliegen, da nachfolgende Catches ignoriert werden, sobald ein Typ übereinstimmt. Beispielsweise muss IOException vor Exception platziert werden, andernfalls meldet der Compiler einen Fehler.

3) Es kann eine oder mehrere Catch-Anweisungen geben. Auch wenn es eine Final-Anweisung gibt, kann es keine Catch-Anweisung wie try-finally geben.

Wenn Sie mehrere Ausnahmen abfangen möchten, können Sie mehrere Catch-Anweisungen verwenden. JDK7 und höher bieten eine andere Möglichkeit: Multi-Catch.

try{
    // other code
} catch (IOException | SQLException ex) {
    throw ex;  
}

4). Ein leerer Catch-Block macht den Zweck der Ausnahme zunichte, außer beim Schließen von FileInputStream, da Sie den Status der Datei nicht geändert haben, sodass Sie keine Wiederherstellungsaktionen durchführen müssen und die erforderlichen Informationen aus der Datei gelesen wurden . Es besteht also keine Notwendigkeit, den laufenden Betrieb zu beenden.

Ein paar Punkte, die Sie zu „final“ beachten sollten:

1 Der Code in „final“ wird immer ausgeführt, es sei denn, die virtuelle Maschine wird beendet, wenn eine try- oder Catch-Anweisung ausgeführt wird (System.exit(1). )).

2). Der „finally“-Block kann einige Ressourcenbereinigungsarbeiten durchführen, z. B. das Schließen von Dateien, das Schließen von Cursorn usw.

3), schließlich ist eine Blockierung nicht erforderlich.

Wenn außerdem die Return-Anweisung sowohl im try-Block als auch im Finally-Block ausgeführt wird, ist der endgültige Rückgabewert der Rückgabewert in final.

2. Abnormale Kette

常常想要在捕获一个异常后抛出另外一个异常，并且希望把原始异常信息保存下来，这就是异常链。在JDK1.4以后，Throwable子类在构造器 中可以接受一个cause对象作为参数，表示原始异常，通过这样把原始异常传递给新的异常，使得即使在当前位置创建并抛出了新的异常，也能通过这个异常链 追踪到异常最初发生的位置。

但在Throwable子类中，只有Error, Exception, RuntimeException三类异常类提供了带cause参数的构造器，其它类型的异常则需要通过initCause()方法。例如定义了CustomException类，可以这样使用：

CustomException cmex = new CustomException();
cmex.initCause(new NullPointerException);
throw cmex;

这样一来，CustomException继承自Exception或RuntimeException，就属于自定义异常了。

一般来说，自定义异常的作用有以下情形：

1)、将检查型异常转换为非检查型异常。

2)、在产生异常时封装上下文信息、定义异常码、收集环境对象，有利于信息的传递。

异常使用指南

1、在知道该如何处理的情况下才捕获异常。

2、自定义异常类型，用以封装所有的检查型异常。

3、在程序的边界进行异常捕获。如服务端相应客户端的请求，在出口处catch内部有可能产生的异常，并统一throw一个封装过的异常给客户端，免得暴露服务端敏感信息。

4、只针对异常的情况才使用异常。不要在所有的代码中习惯性地使用try-catch，因为这会影响性能。

5、抛出与抽象相对的异常。如果方法抛出的异常与它执行的任务没有明显的联系，这种情形会使人不知所措。为了避免这个问题，更高层的实现应该捕获 低层的异常，同时抛出可以按照高层抽象进行解释的异常，这种做法被称为异常转译（exception translation），如下：

try{
    // use lower-level abstraction to do our bidding
} catch(LowerLevelException ex){
    throw new HigherLevelException(...);
}

另外一种特殊的异常转译称为异常链，上面已作描述。如果低层的异常对于调试导致高层异常的问题非常有帮助，使用异常链就很合适。高层的异常提供访问方法（Throwable.getCause）来获得低层的异常。

6、每个方法抛出的异常要有文档描述。利用Javadoc的@throws标记，记录抛出每个异常的条件。如果一个方法可能抛出多个异常，不要使 用这些异常类的某个超类。如不要声明一个方法“throws Exception”或“throws Throwable”，这将没有任何指导信息。

Das obige ist der detaillierte Inhalt vonWas ist eine Ausnahme in Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!