☾ Java / Ausnahmebehandlung

Der zweite Teil einer Serie, in der ich nicht für immer gut bin.

✴︎ Was ist eine Ausnahme?

Selbst wenn das Programm erfolgreich kompiliert wird, kann bei der Ausführung ein Fehler auftreten. In Java werden zur Laufzeit auftretende Fehler als ** Ausnahmen ** bezeichnet. Das Auftreten einer Ausnahme heißt ** eine Ausnahme wird ausgelöst **.

✴︎ Ausnahmebehandlung

Wenn eine Ausnahme ausgelöst wird und das Programm keine Verarbeitung für die Ausnahme beschreibt, wird das Programm zwangsweise beendet **.

Das folgende Sample.java löst eine Ausnahme aus, da es außerhalb der Elemente des vorbereiteten Arrays zugreift.

1¥Sample.java

public class Sample {
  public static void main(String[] args) {
    int[] num = {10, 20, 30};
    for (int i=0; i<4; i++) {
      System.out.print("num :" + num[i]);
      System.out.println(" : " + (i+1) + "Zweite Schleife"); 
    }
    System.out.println("--end--");
  }
}

Ausführungsergebnis

num : 10 :1. Schleife
num : 20 :Zweite Schleife
num : 30 :3. Schleife
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3
        at Sample.main(Sample.java:5)

In dieser Sample.java wird ein Array vorbereitet und jedes Element mit der for-Anweisung ausgegeben. Die Java-Ausführungsumgebung löst jedoch eine Ausnahme aus, da die vierte Schleife außerhalb der Elemente des Arrays zugreift. Wenn Sie sich das Ausführungsergebnis ansehen, können Sie sehen, dass das Programm zur Hälfte beendet wurde, da die Ausgabe von "--end--" in der 8. Zeile nicht ausgegeben wird. Anwendungen, die weiterhin ausgeführt werden, müssen aufgrund möglicher Laufzeitfehler daran gehindert werden, abgebrochen zu werden. Daher verwendet Java einen Mechanismus namens ** Ausnahmebehandlung **. Die Ausnahmebehandlung beschreibt, was zu tun ist, wenn eine Ausnahme auftritt, wodurch das Programm die Ausführung fortsetzen kann, ohne getötet zu werden.

✴︎ aktivierte und deaktivierte Ausnahmen

Es gibt zwei Arten von Java-Ausnahmeklassen: ** aktivierte Ausnahmen ** und ** nicht aktivierte Ausnahmen . Die aktivierte Ausnahme ist eine Ausnahme, die aufgrund einer anderen Umgebung als der Java-Ausführungsumgebung wie z. B. DB auftritt. Auf der anderen Seite sind nicht aktivierte Ausnahmen Ausnahmen, die durch ein laufendes Programm verursacht werden ( Laufzeitausnahme **), und Ausnahmen, die durch die Verarbeitung von Programmausnahmen nicht wiederhergestellt werden können, z. B. nicht genügend Speicher. Ein Merkmal der geprüften Ausnahmen ist, dass die Ausnahmebehandlung obligatorisch ist. Nicht aktivierte Ausnahmen bedeuten andererseits, dass die Ausnahmebehandlung ** optional und nicht obligatorisch ** ist. Darüber hinaus werden Ausnahmeklassen in die folgenden drei Typen eingeteilt.

• Fehlerklasse und ihre Unterklassen (ungeprüfte Ausnahme) --RuntimeException-Klasse und ihre Unterklassen (nicht aktivierte Ausnahme)
• Andere Ausnahmeklassen als die RuntimeException-Klasse (aktivierte Ausnahme)

Die Klasse ** Throwable ** ist die Stammklasse der Ausnahmeklasse. Die Klassen ** Error ** und ** Exception ** werden als Unterklassen der Klasse Throwable bereitgestellt. Die Fehlerklasse drückt einen schwerwiegenden Fehler aus, der in der Java-Ausführungsumgebung auftritt, z. B. nicht genügend Speicher. Die Anwendung kann diese Ausnahme nur schwer behandeln. Daher ist die Verarbeitung für die Ausnahme dieser Klasse und Unterklasse ** optional ** Es ist geworden. Die Exception-Klasse drückt einen Fehler aus, der in einer Anwendung auftritt, z. B. "Ein Programm hat versucht, in eine Datei zu schreiben, aber die Datei war nicht vorhanden" oder "Zugriff außerhalb eines Elements des Arrays". Um erfolgreich zu kompilieren, gibt es jedoch zwei Fälle: Zum einen muss die Verarbeitung für diese Ausnahmen beschrieben werden, zum anderen muss sie nicht beschrieben werden. Diese Entscheidung wird nicht von dem getroffen, was Sie tun, sondern von ** welchen Ausnahmeklassen wahrscheinlich als Ergebnis Ihrer Verarbeitung auftreten **. ** Optional **, wenn es sich um eine RuntimeException-Klasse und ihre Unterklassen handelt, ** Erforderlich **, wenn es sich um eine Unterklasse einer anderen Ausnahme als der RuntimeException-Klasse handelt.

✴︎ Hauptausnahmeklassen

Im Folgenden sind einige der von Java bereitgestellten Ausnahmeklassen aufgeführt, die sich auf den Namen der Ausnahmeklasse konzentrieren und darauf, ob er in nicht aktivierten oder aktivierten Ausnahmen enthalten ist. Außerdem haben die in ** Fett ** geschriebenen Ausnahmeklassen eine hohe Häufigkeit von Fragen. Daher empfiehlt es sich, zu überprüfen, wann die Ausnahme auftritt.

1. Fehlerunterklasse (nicht aktivierte Ausnahme: Ausnahmebehandlung ist optional)

2. Unterklasse von RuntimeException (nicht aktivierte Ausnahme: Ausnahmebehandlung ist optional)

3. Andere Ausnahmeunterklassen als RuntimeException (aktivierte Ausnahme: Ausnahmebehandlung erforderlich)

✴︎ Definition der ursprünglichen Ausnahmeklasse

Java bietet viele Ausnahmeklassen, Sie können jedoch auch eigene Ausnahmeklassen definieren. Im Allgemeinen wird es als öffentliche Klasse definiert, die die Ausnahmeklasse erbt.

Sample.java

[Qualifikation]Klasse Klassenname erweitert Ausnahme{ }
Beispiel) öffentliche Klasse MyException erweitert Exception{ }

Durch das Erben der Exception-Klasse erben Sie die Methoden der Exception-Klasse und ihrer Oberklasse, der Throwable-Klasse. Die Throwable-Klasse bietet Methoden zum Extrahieren von Fehlermeldungen aus Ausnahmen und Methoden zum Verfolgen von Fehlern und zum Identifizieren, wo sie auftreten (Fehlerverfolgung).

Wurfbare Hauptmethoden

✴︎ Try-Catch-finally-Block

Es gibt zwei Möglichkeiten, Ausnahmen in Java zu behandeln.

--Versuchen Sie, die Ausnahmebehandlung zu blockieren

• Ausnahmebehandlung durch Schlüsselwort throw

In diesem Abschnitt werden wir uns mit der Ausnahmebehandlung mit dem Block ** try-catch-finally ** befassen. Der try-catch-finally-Block besteht aus einem try-Block, einem catch-Block und einem finally-Block, und jeder Block beschreibt den Prozess wie folgt.

Sample.java

void method() {
  try {
Verarbeitung, die wahrscheinlich eine Ausnahme verursacht;
  } catch (Name der Ausnahmeklasse Variablenname) {
Was tun, wenn eine Ausnahme auftritt?;
  } finally {
Der Prozess, den Sie ausführen möchten;
  }
}

Die Rolle jedes Blocks ist wie folgt.

--try block: Schließen Sie die Stelle, an der wahrscheinlich eine Ausnahme auftritt, mit einem try-Block ein --catch block: Definiert die Verarbeitung, wenn im catch-Block eine Ausnahme auftritt --finally block: Definieren Sie den Prozess, den Sie im finally-Block ausführen möchten, unabhängig davon, ob eine Ausnahme auftritt oder nicht.

Es ist die Rolle des try-catch-finally-Blocks, die von der Java-Ausführungsumgebung ausgelösten Ausnahmeobjekte zu empfangen. Der catch-Block wird mit der folgenden Syntax geschrieben.

Sample.java

catch (Name der Ausnahmeklasse Variablenname) { }
(Beispiel) fangen(ArrayIndexOutOfBoundsException e) { …… }

1 \ Sample.java löst eine Ausnahme mit dem Namen ArrayIndexOutOfBoundsException aus. Definieren Sie sie daher wie im obigen Beispiel. Es ist nicht notwendig, alle Blöcke von try-catch-finally zu beschreiben. Folgende Kombinationen sind möglich.

• try-finally
• try-catch-finally

Verwenden wir nun den Try-Catch-Block, um dem vorherigen Beispiel eine Ausnahmebehandlung hinzuzufügen.

2¥Sample.java

public class Main {
  public static void main(String[] args) {
    int[] num = {10, 20, 30};
    for (int i=0; i<4; i++) {
      try {
        System.out.print("num :" + num[i]);
        System.out.println(" : " + (i+1) + "Zweite Schleife");
      } catch (ArrayIndexOutOfBoundsException e) {    //8. Zeile
        System.out.println("Ausnahme aufgetreten");
      }
    }
    System.out.println("--end--");    //12. Zeile
  }
}

Ausführungsergebnis

num : 10 :1. Schleife
num : 20 :Zweite Schleife
num : 30 :3. Schleife
Ausnahme aufgetreten
--end--

Ähnlich wie bei 1 \ Sample.java wird die Ausnahme in der 4. Schleife ausgelöst, aber das Ausnahmeobjekt wird im catch-Block in der 8. Zeile abgefangen. Infolgedessen kann bestätigt werden, dass die Verarbeitung der 12. Zeile kontinuierlich ausgeführt wird, ohne das Programm zwangsweise zu beenden.

Verwenden Sie den `finally-Block, wenn Sie etwas tun möchten, unabhängig davon, ob eine Ausnahme auftritt oder nicht. Zum Beispiel das Freigeben von Ressourcen (z. B. Schließen einer Datenbank oder Schließen einer Datei). ``

✴︎ Mehrere Catch-Block-Definitionen

Sie können mehrere Catch-Blöcke definieren, um mehrere Ausnahmeklassen zu behandeln, die innerhalb eines Try-Blocks auftreten können.

Sample.java

} catch (Name der Ausnahmeklasse Variablenname) {
wird bearbeitet;
} catch (Name der Ausnahmeklasse Variablenname) { }

Wenn jedoch eine Vererbungsbeziehung zwischen den im catch-Block angegebenen Ausnahmeklassen besteht, ** beschreiben Sie von der Seite der Unterklasse **. Das Schreiben aus einer Superklasse führt zu einem Kompilierungsfehler.

✴︎ throws Zusätzlich zur Ausnahmebehandlung durch den try-catch-finally-Block ist die Ausnahmebehandlung durch das Schlüsselwort ** throw ** möglich. Geben Sie in dieser Methode "** löst den Namen der Ausnahmeklasse **" aus, wenn Sie eine Methode definieren, die eine Ausnahme verursachen kann. Wenn in der Methode ein Objekt der durch Würfe angegebenen Ausnahmeklasse auftritt, wird das Ausnahmeobjekt ** an den Aufrufer der Methode ** übertragen. Die Syntax lautet wie folgt:

Sample.java

[Qualifikation]Rückgabetyp Methodenname(Argumentliste)löst den Namen der Ausnahmeklasse aus{ }

Geben Sie für den Namen der Ausnahmeklasse den Namen der Ausnahmeklasse an, den Sie für Ausnahmen, die innerhalb dieser Methode auftreten können, an den Methodenaufrufer weiterleiten möchten. Wenn mehrere Ausnahmeklassen angegeben werden müssen, listen Sie die Namen der Ausnahmeklassen durch "," (Komma) getrennt auf.

3¥Sample.java

class Test {
  void loop() throws ArrayIndexOutOfBoundsException {
    int[] num = {10, 20, 30};
    for (int i=0; i<4; i++) {
      System.out.println("num : " + num[i]);
    }
  }
}

public class Sample {
  public static void main(String[] args) {
    try {
      Test t = new Test();
      t.loop();
    } catch (ArrayIndexOutOfBoundsException e) {
      System.out.println("Ausnahme aufgetreten");
    }
    System.out.println("--end--");
  }
}

Ausführungsergebnis

num : 10
num : 20
num : 30
Ausnahme aufgetreten
--end--

Die loop () -Methode der Testklasse ist explizit definiert, um eine ArrayIndexOutOfBoundsException-Ausnahme auszulösen. Wenn Sie sich das Ausführungsergebnis ansehen, sehen Sie, dass die Ausnahme, die auf der Seite der loop () -Methode aufgetreten ist, an die Seite der main () -Methode weitergeleitet wird und vom catch-Block der main () -Methode empfangen wird. Selbst wenn Sie den Teil " löst ArrayIndexOutOfBoundsException "löschen, wird eine ArrayIndexOutOfBoundsException-Ausnahme ausgelöst und das Ausführungsergebnis ist dasselbe. Dies liegt daran, dass die aufgetretene Ausnahmeklasse (ArrayIndexOutOfBoundsException) eine ungeprüfte Ausnahme ist und die Ausnahmebehandlung nicht obligatorisch ist, sodass sie problemlos kompiliert und ausgeführt werden kann.

✴︎ throw Ausnahmen können nicht nur von der ausführbaren Java-Datei ausgelöst werden, sondern auch explizit innerhalb des Programms mit dem Schlüsselwort ** throw **. Es ist dem obigen Schlüsselwort throw sehr ähnlich, aber achten Sie darauf, nicht verwirrt zu werden. Mit dem Schlüsselwort throw können Sie ein Ausnahmeobjekt auslösen, das eine von Java bereitgestellte Ausnahmeklasse oder Ihre eigene Ausnahmeklasse an einer beliebigen Stelle instanziiert.

Sample.java

Ausnahmeobjekt auslösen;
(Beispiel 1) Neue IOException auslösen();
(Beispiel 2) IOException e= new IOException();
　　  throw e;

Im Folgenden wird die MyException-Klasse als eindeutige Ausnahmeklasse definiert. Wenn in der checkAge () -Methode der Sample-Klasse ein Wert kleiner als 0 als Argument übergeben wird, wird ein MyException-Objekt erstellt und explizit mit dem Schlüsselwort throw ausgelöst.

4¥Sample.java

class MyException extends Exception {    //Proprietäre Ausnahmeklasse
  private int age;
  public void setAge(int age) { this.age = age; }
  public int getAge() { return this.age; }
}

public class Sample {
  public static void main(String[] args) {
    try {
      int age = -10;
      checkAge(age);    //11. Zeile
    } catch (MyException e) {    //12. Zeile
      System.out.println("Unzulässiger Wert. Alter: " + e.getAge());    //13. Zeile
    }
  }
  public static void checkAge(int age) throws MyException {    //16. Zeile
    if (age>=0) {
      System.out.println("OK");
    } else {    //Zeile 19
      MyException e = new MyException();    //20. Zeile
      e.setAge(age);
      throw e;    //22. Zeile
    }
  }
}

Ausführungsergebnis

Unzulässiger Wert. Alter: -10

Zeile 11 ruft die in Zeile 16 definierte checkAge () -Methode auf. In der 17. Zeile wird ausgewertet, ob der Wert der als Argument empfangenen Altersvariablen 0 oder mehr beträgt. Wenn es nicht 0 oder mehr ist, wechselt die Steuerung in die 19. Zeile oder weniger. Dann wird die in der ersten Zeile vorbereitete ursprüngliche Ausnahmeklasse in der 20. Zeile instanziiert und in der 22. Zeile explizit ausgelöst. Die ausgelöste Ausnahme wird in Zeile 12 des Aufrufers der checkAge () -Methode abgefangen und die Nachricht in Zeile 13 gedruckt.

Die Vorsichtsmaßnahmen zum Überschreiben kommen wieder.