1. Einführung
Versuchen Sie es mit ... Fang ... ist schließlich wahrscheinlich ein Satz, mit dem jeder vertraut ist, und es fühlt sich sehr einfach zu verwenden, und es scheint logisch leicht zu verstehen. Das "Lernen", das ich persönlich erlebt habe, sagte mir jedoch, dass dieses Ding nicht so einfach und gehorsam ist, wie ich es mir vorgestellt habe. Glauben Sie es nicht? Schauen Sie sich dann den Code unten an. Was wird das Ergebnis sein, nachdem es ausgeführt wurde? Schauen Sie sich die Antworten weder rückwärts an, noch lassen Sie den Code ausgeführt werden, um die wirklichen Antworten zu sehen. Wenn Ihre Antwort korrekt ist, müssen Sie keine Zeit damit verschwenden, diesen Artikel zu lesen.
Pakettest; public class testException {public testException () {} boolean tstex () löst Ausnahme aus {boolean ret = true; try {ret = tstex1 (); } catch (Ausnahme e) {System.out.println ("tstex, catch AUCESS"); ret = falsch; werfen e; } endlich {System.out.println ("tstex, schließlich; return value =" + ret); Return Ret; }} boolean testEx1 () löst Ausnahme aus {boolean ret = true; try {ret = tstex2 (); if (! ret) {return false; } System.out.println ("tstex1, am Ende des Versuchs"); Return Ret; } catch (Ausnahme e) {System.out.println ("tstex1, catch AUCECT"); ret = falsch; werfen e; } endlich {System.out.println ("tstex1, schließlich; return value =" + ret); Return Ret; }} boolean testEx2 () löst eine Ausnahme aus {boolean ret = true; Versuchen Sie {int b = 12; int c; für (int i = 2; i> = -2; i--) {c = b / i; System.out.println ("i =" + i); } Return true; } catch (Ausnahme e) {System.out.println ("tstex2, catch AUCESS"); ret = falsch; werfen e; } endlich {System.out.println ("tstex2, schließlich; return value =" + ret); Return Ret; }} public static void main (String [] args) {testException testException1 = new TestException (); try {testException1.Testex (); } catch (Ausnahme e) {e.printstacktrace (); }}} Was ist Ihre Antwort? Ist es die Antwort unten?
i = 2
I = 1
TESTEX2, Ausnahme
TESTEX2, endlich; Rückgabewert = Falsch
TESTEX1, Ausnahme
TESTEX1, endlich; Rückgabewert = Falsch
testex, fangen Sie Ausnahme
TESTEX, schließlich; Rückgabewert = Falsch
Wenn Ihre Antwort wirklich wie oben erwähnt ist, liegen Sie falsch. ^_^, dann schlage ich vor, dass Sie diesen Artikel sorgfältig lesen oder den obigen Code verwenden, um in verschiedenen Situationen zu ändern, auszuführen und zu testen. Sie werden feststellen, dass es viele Dinge gibt, die nicht so einfach sind wie ursprünglich vorgestellt. Veröffentlichen Sie nun die richtige Antwort:
i = 2
I = 1
TESTEX2, Ausnahme
TESTEX2, endlich; Rückgabewert = Falsch
TESTEX1, endlich; Rückgabewert = Falsch
TESTEX, schließlich; Rückgabewert = Falsch
Notiz:
Schließlich sollte Anweisungsblock nicht angezeigt werden, die Rückgabe sollte angezeigt werden. Die obige Rückgabe ist vorzugsweise eine weitere Anweisung, um die relevante Logik zu verarbeiten.
2. Java -Ausnahme
Ausnahmen beziehen sich auf verschiedene Situationen, die unerwartet auftreten, wie z. Java beschreibt verschiedene Ausnahmen durch viele Unterklassen der Throwable -Klasse in der API. Daher sind Java -Ausnahmen Objekte, Fälle von Thrombo -Unterklassen, die Fehlerbedingungen beschreiben, die in einer Codierung auftreten. Wenn eine Bedingung erzeugt wird, macht ein Fehler eine Ausnahme.
Java Exception Class Hierarchy Diagramm:
Abbildung 1 Java Exception Class Hierarchy Diagramm
In Java haben alle Ausnahmen einen gemeinsamen Vorfahren, das throwable (Throwable). Throwable gibt die Gemeinsamkeit von Problemen an, die durch Java -Anwendungen im Code durch Ausnahmemechanismen übertragen werden können.
Throwable: Es gibt zwei wichtige Unterklassen: Ausnahme und Fehler. Beide sind wichtige Unterklassen für die Handhabung von Java -Ausnahmen und enthält eine große Anzahl von Unterklassen.
Fehler: Ein Fehler, den das Programm nicht behandeln kann, was auf ein ernstes Problem beim Ausführen der Anwendung hinweist. Die meisten Fehler beziehen sich nicht mit den Aktionen des Codeautors, sondern stellen Probleme mit dem JVM (Java Virtual Machine) dar, wenn der Code ausgeführt wird. Beispielsweise führt eine java -virtuelle Maschine einen Fehler aus (virtuellem MaschinenError), und ein OutofMemoryError wird angezeigt, wenn das JVM nicht mehr über die Speicherressourcen verfügt, die für die Fortsetzung des Betriebs erforderlich sind. Wenn diese Ausnahmen auftreten, entscheidet sich die Java Virtual Machine (JVM) im Allgemeinen für die Beendet von Threads.
Diese Fehler zeigen, dass der Fehler auftritt, wenn die virtuelle Maschine selbst oder wenn die virtuelle Maschine versucht, die Anwendung auszuführen, wie z. Bei einer gut gestalteten Anwendung sollte er nicht im Wesentlichen versuchen, mit den von ihm verursachten Ausnahmen umzugehen. In Java wird der Fehler durch eine Fehlerunterklasse beschrieben.
Ausnahme: Eine Ausnahme, die das Programm selbst bewältigen kann.
Die Ausnahmeklasse hat eine wichtige Unterklasse, RunTimeException. Die RunTimeException -Klasse und ihre Unterklassen stellen einen Fehler dar, der durch "gemeinsame JVM -Operationen" aufgeworfen wird. Wenn Sie beispielsweise versuchen, eine Null -Objektreferenz, einen Null -Divisor oder ein Array außerhalb der Grenzen zu verwenden, werden eine Laufzeitausnahme (NullPointerexception, Arithmeexception) und ArrayIndexoutOfBoundException erhöht.
Hinweis: Der Unterschied zwischen Ausnahmen und Fehlern: Ausnahmen können vom Programm selbst behandelt werden, Fehler können jedoch nicht behandelt werden.
Im Allgemeinen werden Java -Ausnahmen (einschließlich Ausnahme und Fehler) in geprüfte Ausnahmen und nicht überprüfte Ausnahmen unterteilt.
Ausnahmen können überprüft werden (Ausnahmen, die vom Compiler behandelt werden müssen): Es ist leicht zu erfolgen und vernünftige und tolerante Ausnahmen, wenn das richtige Programm ausgeführt wird. Obwohl die prüfbare Ausnahme eine abnormale Erkrankung ist, ist ihr Auftreten bis zu einem gewissen Grad vorhersehbar, und sobald ein solcher abnormaler Zustand auftritt, muss sie in irgendeiner Weise behandelt werden.
Mit Ausnahme von RunTimeException und ihren Unterklassen sind andere Ausnahmeklassen und deren Unterklassen prüfbare Ausnahmen. Das Merkmal dieser Ausnahme ist, dass der Java-Compiler sie überprüft, dh wenn eine solche Ausnahme im Programm auftritt, fangen sie entweder mit der Versuchs-Catch-Anweisung an oder werfen Sie sie mit der Throw-Klausel, sonst verabschieden die Kompilierung nicht.
Unkontrollierbare Ausnahmen (Ausnahmen, die der Compiler nicht benötigt): einschließlich Laufzeitausnahmen (RunTimeException und seiner Unterklassen) und Fehler (Fehler).
Ausnahme Diese Ausnahme ist in zwei Kategorien unterteilt: Laufzeitausnahme und nicht rechter Ausnahme (Zusammenstellungsausnahme). Diese Ausnahmen sollten im Programm so weit wie möglich behandelt werden.
Ausnahmen von Laufzeit: Sie sind alle RunTimeException-Klasse und ihre Unterklassenausnahmen, wie z. Diese Ausnahmen werden im Allgemeinen durch Programmlogikfehler verursacht, und Programme sollten solche Ausnahmen aus logischer Sicht so weit wie möglich vermeiden.
Das Merkmal der Laufzeitausnahme ist, dass der Java -Compiler es nicht überprüfen wird. Das heißt, wenn eine solche Ausnahme im Programm auftreten kann, auch wenn sie nicht mit der Aussageerklärung erfasst und mit der Throw-Klausel geworfen wird, wird sie kompiliert und bestanden.
Nicht-Runtime-Ausnahme (Zusammenstellungsausnahme): ist eine andere Ausnahme als RunTimeException und gehört zur Ausnahmeklasse und ihren Unterklassen in Bezug auf Typ. Aus der Sicht der Programmsyntax muss eine Ausnahme verarbeitet werden. Wenn es nicht verarbeitet wird, kann das Programm nicht kompiliert und bestanden werden. Wie IOException, SQLEXception usw. und benutzerdefinierte Ausnahmeausnahmen, im Allgemeinen werden keine benutzerdefinierten Überprüfungsausnahmen überprüft.
3. Mechanismus zur Ausnahmehandhabung
In Java -Anwendungen lautet der Ausnahmebehandlungsmechanismus: Ausnahmen werfen und Ausnahmen fangen.
Wirf eine Ausnahme: Wenn ein Fehler in einer Methode auftritt und eine Ausnahme erhöht, erstellt die Methode ein Ausnahmebobjekt und liefert sie an das Laufzeitsystem. Das Ausnahmeobjekt enthält Ausnahmeinformationen wie den Ausnahmetyp und den Programmstatus, wenn die Ausnahme auftritt. Das Laufzeitsystem ist dafür verantwortlich, Code zu finden und auszuführen, um Ausnahmen zu verarbeiten.
Ausnahme von Catch: Nach der Methode wird das Laufzeitsystem auf die Suche nach einem geeigneten Ausnahmebehandler umgewandelt. Ein potenzieller Ausnahmebehandler ist eine Sammlung von Methoden, die im Anrufstapel wiederum verbleiben, wenn eine Ausnahme auftritt. Wenn der Ausnahmetyp, den der Ausnahmeprozessor verarbeiten kann, mit dem von der Methode geworfenen Ausnahmetyp übereinstimmt, handelt es sich um einen geeigneten Ausnahmeberecht. Das Laufzeitsystem beginnt mit der Methode, bei der eine Ausnahme auftritt, und schaut dann wieder auf die Methoden des Anrufstapels zurück, bis eine Methode mit einem geeigneten Ausnahmebehandler findet und es ausführt. Wenn das Laufzeitsystem den Anrufstack durchquert und keinen geeigneten Ausnahmebehandler findet, endet das Laufzeitsystem. Gleichzeitig bedeutet dies die Beendigung des Java -Programms.
Für Laufzeitausnahmen, Fehler oder nachweisbare Ausnahmen sind die von der Java -Technologie erforderlichen Ausnahmebehandlungsmethoden unterschiedlich.
Aufgrund der nicht nachweisbaren Laufzeitausnahmen sieht Java, um die Anwendung besser und einfacher zu implementieren, dass die Laufzeitausnahmen automatisch vom Java -Laufzeitsystem geworfen werden, sodass die Anwendung die Ausnahmen von Laufzeiten ignorieren kann.
Bei Fehlern, die während des Methodenbetriebs auftreten können, ermöglicht Java die Methode, keine Deklaration abzugeben, wenn die Methode nicht erfasst werden soll. Da die meisten Fehlerausnahmen Situationen sind, die niemals auftreten können, und auch Ausnahmen sind, die angemessene Anwendungen nicht fangen sollten.
Bei allen prüfbaren Ausnahmen stipendiert Java, dass eine Methode gefangen oder außerhalb der Wurfmethode deklariert werden muss. Das heißt, wenn eine Methode eine prüfbare Ausnahme nicht einnimmt, muss sie erklären, dass die Ausnahme ausgelöst wird.
Eine Methode, die Ausnahmen erfassen kann, erfordert eine entsprechende Art von Ausnahmebehandler. Die gefangene Ausnahme kann durch eine Ausnahme verursacht werden, die durch eine eigene Aussage oder eine Ausnahme, die von einer genannten Methode oder einem Java -Laufzeitsystem usw. ausgeliefert wird, usw. Mit anderen Worten, die Ausnahme, dass eine Methode fangen kann, muss eine Ausnahme sein, die von Java -Code irgendwo ausgelöst wird. Einfach ausgedrückt werden Ausnahmen immer zuerst geworfen und dann gefangen.
Jeder Java -Code kann Ausnahmen wie: Code selbst, Code aus dem Java Development Environment -Paket oder Java -Laufzeitsystem ausführen. Egal wer es ist, Sie können eine Ausnahme durch die Java -Wurf -Erklärung machen.
Jede Ausnahme aus der Methode muss mit der Throw -Klausel verwendet werden.
Fangausnahmen werden durch Versuchs-Catch-Anweisungen oder Versuchs-Catch-finaler Aussagen erzielt.
Im Allgemeinen muss Java feststellen, dass prüfbare Ausnahmen gefangen oder geworfen werden müssen. Ermöglicht die ignorierende nicht überprüfte RunTimeException und Fehler.
3.1 Ausnahmen fangen: Versuchen Sie, fangen und schließlich fangen und schließlich
1. TRYS-CATCH-AUSGABE
In Java werden Ausnahmen von einer Versuchserklärung erfasst. Die allgemeine Syntaxform lautet:
Versuchen Sie {// Programmcode, wobei Ausnahmen auftreten können} catch (Typ1 ID1) {// Catch und behandeln Sie mit Ausnahmetyp, die von Versuch Typ1} catch (Typ2 ID2) {// Catch und Deviopy mit Ausnahmetyp, die von Try Type2} geworfen wurdenEin Paar Zahnspangen, nachdem das Schlüsselwort versuchen, ein Stück Code zu wickeln, das möglicherweise eine Ausnahme hat, die als Überwachungsbereich bezeichnet wird. Wenn während der Java -Methode während des Laufens eine Ausnahme auftritt, wird ein Ausnahmungsobjekt erstellt. Werfen Sie die Ausnahme außerhalb des Überwachungsbereichs, und das Java -Laufzeitsystem versucht, eine passende Fangklausel zu finden, um die Ausnahme zu erhalten. Wenn es eine passende Fangklausel gibt, führen Sie seinen Ausnahmebehandlungscode aus und die Anweisung Try-Catch endet.
Das Prinzip der Übereinstimmung lautet: Wenn das geworfene Ausnahmeobjekt zur Ausnahmeklasse der Fangklausel gehört oder zu einer Unterklasse der Ausnahmeklasse gehört, wird berücksichtigt, dass das generierte Ausnahmeobjekt mit dem vom Fangblock erfassten Ausnahmetyp übereinstimmt.
Beispiel 1 Fang die Ausnahme von "Dividter Is 0" durch die Wurfanweisung.
public class testException {public static void main (String [] args) {int a = 6; int b = 0; Versuchen Sie es mit {// Versuchen Sie die Überwachungsbereich, wenn (b == 0) neue Arithmexception () werfen; // Ausnahme durch Wurfanweisung System.out.println ("Der Wert von A/ B ist:" + a/ b); } catch (AritheMeticexception e) {// Catch Catch Exception System.out.println ("Das Programm hat eine Ausnahme, und die Variable B kann nicht 0 sein"); } System.out.println ("Das Programm endet normal."); }}Auslaufergebnis: Das Programm hat eine Ausnahme und die Variable B kann nicht 0 sein.
Das Programm endet normal.
Beispiel 1 Verwenden Sie im Versuchsüberwachungsbereich, wenn Sie eine Erklärung an Richter beurteilen. Wenn die Fehlerbedingung von "Teiler ist 0" festgelegt wird, wird eine Arithelexception -Ausnahme erstellt, und die Wurfanweisung läuft die Ausnahme auf das Java -Laufzeitsystem. Das System findet einen übereinstimmenden Ausnahmebehandler und führt den entsprechenden Ausnahmebehandlungscode aus. Ausdruck "Das Programm hat eine Ausnahme und die Variable B kann nicht 0 sein" Die Anweisung Try-Catch endet und setzt den Programmfluss fort.
In der Tat ist AritheMeticexception wie "Teiler is 0" eine Unterklasse von RunTimexception. Die Laufzeitausnahme wird automatisch vom Laufzeitsystem ausgeworfen, und es müssen keine Wurfanweisung verwendet werden.
Beispiel 2: Fangen Sie die durch den "Teiler is 0" verursachte Arithmeticexception -Ausnahme, die während des Laufzeitsystems automatisch geworfen wird.
public static void main (String [] args) {int a = 6; int b = 0; try {system.out.println ("Der Wert von a / b ist:" + a / b); } catch (AritheMeticexception e) {System.out.println ("Das Programm hat eine Ausnahme, und die Variable B kann nicht 0 sein"); } System.out.println ("Das Programm endet normal."); }}Auslaufergebnis: Das Programm hat eine Ausnahme und die Variable B kann nicht 0 sein.
Das Programm endet normal.
Anweisung in Beispiel 2:
System.out.println ("A/Bs Wert ist:" + a/b);Während der Laufzeit wurde ein Fehler von "Teiler ist 0" generiert, und eine Arithmexception -Ausnahme wurde erhöht. Das Laufzeitsystem erstellt ein Ausnahmebobjekt und wirft einen Überwachungsbereich aus, stimmt stattdessen mit dem entsprechenden Ausnahmebehandler überein und führt den entsprechenden Ausnahmebehandlungscode aus.
Da die Kosten für die Überprüfung der Laufzeitausnahmen viel größer sind als die Vorteile von Ausnahmen, können keine Laufzeitausnahmen festgestellt werden. Der Java -Compiler ermöglicht es, Laufzeitausnahmen zu ignorieren, und eine Methode kann weder fangen noch deklarieren, um Laufzeitausnahmen zu werfen oder zu deklarieren.
Beispiel 3: Kein Fang oder Deklar, dass die Laufzeitausnahme ausgelöst wird.
public class testException {public static void main (String [] args) {int a, b; a = 6; B = 0; // Der Wert von Divisor B ist 0 system.out.println (a / b); }}Auslaufergebnisse:
Ausnahme im Thread "Haupt" java.lang.arithmeTexception: / nach Null
bei test.TestException.main (testException.java:8)
Beispiel 4 Das Programm hat möglicherweise eine Ausnahme des Divisors 0 und eine Ausnahme des Array-Indexs nicht.
public class testException {public static void main (String [] args) {int [] intarrray = new int [3]; Versuchen Sie {für (int i = 0; i <= intarrray.length; i ++) {intarrray [i] = i; System.out.println ("intarrray [" + i + "] =" + intarrray [i]); System.out.println ("Intarrray [" + i + "] Modul" + (i - 2) + "Werte:" + intarray [i] % (i - 2)); }} catch (arrayIndexoutOfBoundSexception e) {System.out.println ("IntArray Array-Index Out-of-Bounds-Ausnahme."); } catch (AritheMeticexception e) {System.out.println ("Ausnahme des Divisors 0."); } System.out.println ("Programm endet normal."); }}Auslaufergebnisse:
Intarrray [0] = 0
Intarrray [0] Modul-2-Wert: 0
Intarrray [1] = 1
Der Wert von Intarrray [1] Modulo-1: 0
Intarrray [2] = 2
Ausnahme des Divisors 0.
Das Programm endet normal.
Beispiel 5 Das Programm kann eine Ausnahme des Divisors 0 erleben, und es kann auch eine Ausnahme von Array -Einweisen auftreten. Während des Ausgangsprogramms übereinstimmt der AritheMeticexception -Ausnahmestyp zuerst, sodass die Anweisung für eine passende Catch -Anweisung ausgeführt wird:
catch (AritheMeticexception e) {System.out.println ("Ausnahme des Divisors 0."); }Es ist zu beachten, dass ein Catch -Fang den passenden Ausnahmetyp fangen, er den Ausnahmebehandlungscode eingibt. Sobald die Verarbeitung beendet ist, bedeutet dies, dass die gesamte Anweisung Try-Catch endet. Andere Fangklauseln haben nicht mehr die Chance, Ausnahmetypen zu erreichen und zu fangen.
Java beschreibt Ausnahmetypen durch Ausnahmeklassen, und die Hierarchie von Ausnahmeklassen ist in Abbildung 1 dargestellt. Für Ausnahmeprogramme mit mehreren Fangklauseln sollten Sie versuchen, die Fangklausel zu platzieren, die die zugrunde liegende Ausnahmeklasse zuerst erfasst, und versuchen, die Fangklausel zu platzieren, die den relativ hochrangigen Ausnahmekurs später fängt. Andernfalls wird die Fangklausel, die die zugrunde liegende Ausnahmeklasse erwischt, wahrscheinlich blockiert.
Die RunTimeException -Ausnahmeklasse enthält verschiedene häufige Ausnahmen zur Laufzeit, und die AritheMeticexception -Klasse und die ArrayIndexoutOfBoundSexception -Klasse sind beide Unterklassen. Daher sollte die Fangklausel der RunTimeException -Ausnahmeklasse am Ende platziert werden, ansonsten kann sie die nachfolgende Ausnahmeregelung blockieren oder einen Kompilierungsfehler verursachen.
2. Versuch-Catch-finaler Anweisung
Die Anweisung Try-Catch kann auch den dritten Teil enthalten, der endgültige Klausel ist. Es zeigt an, was ausgeführt werden soll, unabhängig davon, ob eine Ausnahme auftritt oder nicht. Die allgemeine Syntaxform der Aussage für Try-Catch-final lautet:
Versuchen Sie {// Programmcode, der eine Ausnahme auftreten kann} catch (Typ1 ID1) {// Fang und verarbeiten Sie den von Versuch Typ1} catch (Typ2 ID2) {// fangen und verarbeiten den Ausnahmetyp, der durch Versuch Typ 2} endlich {// Block von Aussagen ausgeführt wird, die ausgeführt werden, unabhängig davon, ob eine Ausnahme auftritt}}}Beispiel 6 Ausnahmehandler mit endgültiger Klausel.
public class testException {public static void main (String args []) {int i = 0; String Greetings [] = {"Hallo Welt!", "Hallo Welt !!", "Hallo Welt !!!" }; while (i <4) {try {// Achten Sie besonders auf die Gestaltung der Schleifensteuerungsvariable I, um zu vermeiden, dass unendliches Schleifen system.out.println (Grüße [i ++]) verursacht wird; } catch (arrayIndexoutOfBoundSexception e) {System.out.println ("Arraysubscript Out-of-Bounds-Ausnahme"); } endlich {System.out.println ("----------------------"); }}}}Auslaufergebnisse:
Hallo Welt!
--------------------------------
Hallo Welt !!
--------------------------------
Hallo Welt !!!
--------------------------------
Array -Index -Ausnahme außerhalb der Grenzen
--------------------------------
In Beispiel 6 achten Sie bitte besondere Aufmerksamkeit auf die Gestaltung des Statement -Blocks in der Try -Klausel. Wenn das Design wie folgt ist, tritt eine tote Schleife auf. Wenn so konzipiert wie:
try {System.out.println (Grüße [i]); i ++; }Zusammenfassung:
Versuchen Sie es Block: Wird verwendet, um Ausnahmen zu fangen. Danach können null oder mehr Fangblöcke angeschlossen werden. Wenn es keinen Hakenblock gibt, muss dies von einem endgültigen Block gefolgt werden.
Catch Block: Wird verwendet, um mit Ausnahmen zu handhaben, die von Versuch gefangen wurden.
Schließlich Block: Die Anweisungen im endgültigen Block werden unabhängig davon ausgeführt, ob die Ausnahme gefangen oder verarbeitet wird. Wenn in einem Try -Block- oder Catch -Block eine Rückgabeanweisung auftritt, wird der endgültige Anweisungsblock
Führt vor der Methode aus. In den folgenden 4 Sonderfällen wird der endgültige Block nicht ausgeführt:
1) Eine Ausnahme trat im endgültigen Anweisungsblock auf.
2) Verwenden Sie System.exit () im vorherigen Code, um das Programm zu beenden.
3) Der Thread, in dem sich das Programm befindet, stirbt.
4) Schalten Sie die CPU aus.
3.. Try-Catch-final-Regel (grammatikalische Regel für Ausnahmebehandlung):
1) Ein Haken oder schließlich muss nach dem Versuch hinzugefügt werden. Nach dem Try -Block können der Fang und schließlich gleichzeitig verbunden werden, aber es gibt mindestens einen Block.
2) Die Blockreihenfolge muss befolgt werden: Wenn der Code sowohl Fang als auch blockiert, muss der Fangblock nach dem Try -Block platziert werden.
3) Der Fangblock bezieht sich auf den Typ der entsprechenden Ausnahmeklasse.
4) Ein Try -Block kann mehrere Fangblöcke haben. Wenn ja, wird der erste passende Block ausgeführt. Das heißt, die virtuelle Java -Maschine entspricht den tatsächlichen Ausnahmebobjekten mit den Ausnahmetypen, die von jedem Catch -Code -Block in Sequenz deklariert sind. Wenn das Ausnahmeobjekt ein Ausnahmetyp oder eine Instanz seiner Unterklasse ist, wird der Catch -Code -Block ausgeführt und kein anderer Catch -Code -Block wird ausgeführt.
5) verschachtelte Try-Catch-felal.
6) In der Try-Catch-final-Struktur kann eine Ausnahme zurückgeworfen werden.
7) Zusätzlich zu den folgenden Situationen endet die Ausführung von schließlich: Die JVM endet vorzeitig (System.exit (int)); wirft eine ungehandelte Ausnahme in den endgültigen Block; Der Computer wird ausgeschaltet, abgefeuert oder von einem Virus angegriffen.
V.
1) Wenn der Versuch keine Ausnahme erfasst: Die Anweisungen im Block Anweisungsblock werden nacheinander ausgeführt, und das Programm überspringt den Catch -Anweisung -Block und führt den schließlich Anweisungsblock und nachfolgende Anweisungen aus;
2) Wenn der Versuch eine Ausnahme erfasst, behandelt der Block für Catch -Anweisungen diese Ausnahme nicht: Wenn eine Ausnahme in einer Anweisung im Try -Anweisungsblock und im Catch -Anweisungsblock auftritt, der diese Ausnahme nicht behandelt, wird die Ausnahme zur Verarbeitung in die JVM geworfen, und die Anweisung in der endgültigen Erklärung wird weiterhin ausgeführt, aber die Anweisung nach dem Schlussfolgerung wird nicht ausgeführt.
3) Wenn ein Versuch eine Ausnahme aufnimmt, wird der Catch -Anweisungsblock diese Ausnahme behandelt: Sie wird in der Reihenfolge der Try -Anweisungsblock ausgeführt. Wenn eine Ausnahme auftritt, wenn eine Ausnahme in einer bestimmten Aussage auftritt, wird das Programm zum Block Catch Anweisungen springen und sie nacheinander übereinstimmen. Finden Sie den entsprechenden Handler. Andere Catch -Anweisungsblöcke werden nicht ausgeführt. Im Block Anweisungsblock wird die Anweisung nach einer Ausnahme nicht ausgeführt. Nach der Ausführung des Catch -Anweisungsblocks wird die Anweisung im endgültigen Anweisungsblock ausgeführt, und schließlich wird die Anweisung nach dem endgültigen Anweisungsblock ausgeführt.
Illustration der Ausführung von Try-, Fang- und Schlussfolgerungblöcken:
Abbildung 2 zeigt die Ausführung von Try-, Fang- und Anweisungsblöcken
3.2 eine Ausnahme werfen
Jeder Java -Code kann Ausnahmen wie: Code selbst, Code aus dem Java Development Environment -Paket oder Java -Laufzeitsystem ausführen. Egal wer es ist, Sie können eine Ausnahme durch die Java -Wurf -Erklärung machen. Jede Ausnahme aus der Methode muss mit der Throw -Klausel verwendet werden.
1. Throws Throw -Ausnahme
Wenn eine Methode eine Ausnahme hat, aber nicht in der Lage ist, eine solche Ausnahme zu behandeln, können Sie die Throw -Klausel verwenden, um die geworfene Ausnahme bei der Methodenerklärung zu deklarieren. Zum Beispiel kann ein Auto beim Laufen versagen, und das Auto selbst kann diesen Fehler nicht bewältigen. Lassen Sie den Fahrer damit umgehen.
Die Anweisung Throws wird verwendet, um die Art von Ausnahme zu deklarieren, wenn die Methode definiert ist. Wenn der Ausnahme -Ausnahmetyp geworfen wird, wird die Methode erklärt, um alle Ausnahmen zu werfen. Mehrere Ausnahmen können mit Commas aufgeteilt werden. Das Syntaxformat der Throws -Anweisung lautet:
MethodName löst Ausnahme1, Ausnahme2, .., Exceptionn {} aus Wirft nach dem Methodennamen Exception1, Exception2, ..., ExceptionN die Liste der Ausnahmen, die ausgeworfen werden sollen. Wenn eine Methode eine Ausnahmliste von Ausnahmen ausgelöst hat, wird die Methode keine Ausnahmen dieser Typen und ihrer Unterklasse -Typen behandelt, sondern wird auf die Methode geworfen, die die Methode aufruft und von dieser abgewickelt wird. Zum Beispiel:
importieren java.lang.exception; public class testException {static void pop () löscht negativeArraysizeexception {// die Methode definieren und die negativenearraysizeexception-Ausnahme int [] arr = new int [-3] werfen; // Erstellen Sie ein Array} public static void main (String [] args) {// Hauptmethode try {// Versuchen Sie, Ausnahmeinformationen pop () zu verarbeiten; // rufen Sie die Pop () -Methode auf} catch (negativeReSizeexception e) {System.out.println ("Ausnahme, die von der Pop () -Methode"); // Ausnahmeinformationen ausgeben}}}Nachdem Sie die Ausnahme an den Anrufer über das Schlüsselwort Throws geworfen haben, können Sie es weiterhin auswerfen, wenn der Anrufer nicht die Ausnahme abwickeln möchte. Am Ende muss es jedoch einen Anrufer geben, der die Ausnahme bewältigen kann.
Die POP -Methode behandelt die Ausnahme nicht negativesarraysizeexception, sondern wird von der Hauptfunktion behandelt.
Die Regel für Würfe, um Ausnahmen zu werfen:
1) Wenn es sich um eine deaktivierte Ausnahme, dh Fehler, RunTimeException oder deren Unterklassen handelt, können Sie die Ausnahme erklären, dass sie ohne Verwendung des Schlüsselworts Throws geworfen werden sollen, und die Zusammenstellung wird weiterhin reibungslos verläuft, aber es wird zur Laufzeit vom System geworfen.
2) Alle überprüften Ausnahmen, die mit der Methode geworfen werden können, müssen deklariert werden. Das heißt, wenn eine Methode eine prüfbare Ausnahme hat, wird sie entweder mit einer Versuchsanweisung erfasst oder mit einer Throw-Klauseldeklaration wirft, da sie sonst einen Kompilierfehler verursacht.
3) Nur wenn eine Ausnahme ausgelöst wird, muss der Anrufer der Methode die Ausnahme verarbeiten oder wiederwerfen. Wenn der Methode -Anrufer die Ausnahme nicht bewältigen kann, sollte er sie weiterhin werfen, anstatt sie ganz zu schlucken.
4) Die aufrufende Methode muss alle Regeln zur Bearbeitung und Deklaration der Ausnahme und Deklaration befolgen. Wenn eine Methode überschrieben wird, können Ausnahmen, die sich von der überschriebenen Methode unterscheiden, nicht deklariert werden. Jede deklarierte Ausnahme muss eine ähnliche oder Unterklasse der von der überragenden Methode deklarierten Ausnahme sein.
Zum Beispiel:
void method1 () löscht IOException {} // legal // Compilation -Fehler aus, IOException muss gefangen oder deklariert werden, um void method2 () {method1 () zu werfen; } // legal, deklarieren Sie, um iOException void method3 () zu werfen. } // legal, deklarieren Sie, dass ioException eine Unterklasse von Ausnahme void method4 () ausreißt {method1 (); } // Legal, Capture ioException void method5 () {try {method1 (); } catch (ioException e) {…}} // Kompilierungsfehler, Sie müssen die void method6 () {try {method1 () fangen oder deklarieren; } catch (ioException e) {throw New Exception ();}} // legal, Declare throw Exception void method7 () löst Ausnahme aus {try {method1 (); } catch (ioException e) {neue Ausnahme werfen ();}} Die Grundlage für die Bestimmung, dass eine Ausnahme in einer Methode auftreten kann, lautet wie folgt:
1) In der Methode enthält eine Wurfanweisung. Beispielsweise hat der Catch -Code -Block der obigen Methode () eine Wurfanweisung.
2) Andere Methoden werden aufgerufen, und andere Methoden verwenden Schläfenklausel, um eine Ausnahme von Wurf zu erklären. Beispielsweise nennt die Methode method3 () die Methode1 () -Methode, und die Methode Method1 () methodie erklärt, dass eine IOException geworfen wird, sodass eine IOException in der Methode3 () -Methode auftreten kann.
2. Verwenden Sie Wurf, um eine Ausnahme zu werfen
Wurf erscheint immer im Funktionskörper und wird verwendet, um eine Ausnahme vom Typ Throwable zu werfen. Das Programm endet unmittelbar nach der Throw-Anweisung, die Anweisung, nachdem es nicht ausgeführt werden kann, und suchen Sie in allen Versuchsblöcken, die sie enthalten (möglicherweise in der Aufruffunktion der oberen Ebene), nach Versuchsblöcken, die die Fangklausel enthalten, die von innen nach außen entspricht.
Wir wissen, dass Ausnahmen Instanzobjekte der Ausnahmeklasse sind und Instanzobjekte der Ausnahmeklasse erstellen können, die durch Wurfanweisung geworfen werden können. Das Syntaxformat dieser Aussage lautet:
neue Ausnahmename werfen;
Werfen Sie zum Beispiel ein Ausnahmebiel der IOException -Klasse:
neue IOException werfen;
Es ist zu beachten, dass nur Instanzobjekte wirft, die Klassenwurf- oder Unterklassen werfen können. Die folgende Operation ist falsch:
neue Zeichenfolge werfen ("Ausnahme");Dies liegt daran, dass String keine Unterklasse der Throwable -Klasse ist.
Wenn eine Check -Ausnahme ausgelöst wird, sollten Sie auch die Art der Ausnahme erklären, dass die Methode den Method -Header einwerfen kann. Der Anrufer dieser Methode muss auch nach dem Umgang mit der geworfenen Ausnahme prüfen.
Wenn alle Methoden die erworbene Ausnahmeberechnung für Schicht werfen, verarbeitet der JVM sie schließlich und die Verarbeitung ist auch sehr einfach, weshalb die Ausnahmenachricht und die Stapelinformationen drucken soll. Wenn ein Fehler oder eine RunTimeException geworfen wird, hat der Anrufer der Methode die Möglichkeit, die Ausnahme zu verarbeiten.
Pakettest; importieren java.lang.exception; public class testException {static int quotient (int x, int y) löst MyException aus {// definieren Sie eine Ausnahme, um eine Ausnahme zu werfen, wenn (y <0) {// bestimmen Sie, ob der Parameter weniger als 0 neue Myexception werfen ("Der Teiler kann keine negative Zahl sein"); // Ausnahmeinformationen} return x/y; // Rückgabewert} public static void main (String args []) {// Hauptmethode int a = 3; int b = 0; Versuchen Sie {// Versuchen Sie die Anweisung enthält Anweisungen, die möglicherweise Ausnahmen int result = quotient (a, b) haben können; // METHODE MOTEENT ()} catch (myException e) {// benutzerdefinierte Ausnahmesysteme verwandeln. // Ausnahme -Ausnahmeinformationen} catch (ArithmeMexception e) {// ArithmeException -Ausnahme -System.out.Out.println ("Divorceipt kann nicht 0"); // Ausgabe von Eingabeaufforderungsinformationen} catch (Ausnahme E) {// andere Ausnahmen system.out.println verarbeiten ("Andere Ausnahmen sind im Programm aufgetreten"); // Ausgabe von Eingabeaufforderungsinformationen}}} Klasse MyException erweitert die Ausnahme {// Benutzerdefinierte Ausnahmeklassen -String -Nachricht erstellen; // Definieren von String Type Variable public myException (String errormessagr) {// übergeordnete Klassenmethode message = errormessagr; } public String getMessage () {// überschreiben Sie GetMessage () Methodenrückgabenachricht; }}3.3 Ausnahmekette
1) Wenn der Quotient (3, -1) aufgerufen wird, wird eine Myexception-Ausnahme auftreten und das Programm wird in den Catch (Myexception E) -Codeblock übertragen, um auszuführen;
2) Wenn der Quotient (5,0) aufgerufen wird, wird eine Arithmeticexception -Ausnahme aufgrund des Fehlers "Teiler ist 0" erhöht. Es gehört zur Laufzeit -Ausnahmeklasse und wird automatisch vom Java -Laufzeitsystem geworfen. Die Methode quotient () fängt nicht die ArithmeMexception -Ausnahme an. Das Java -Laufzeitsystem sucht nach der Hauptmethode entlang des Method -Call -Stacks und lädt die geworfene Ausnahme auf den Anrufer der Quotienten () -Methode hoch:
int result = quotient (a, b); // Methodenquotienten aufrufen ()
Da sich diese Aussage im Versuchsüberwachungsbereich befindet, wird das Arithmeticexception mit "Teiler 0" vom Java -Laufzeitsystem übergeben und entspricht der Catch -Klausel:
catch (AritheMeticexception e) {// ARITHMETICException -Ausnahme -System. // Eingabeaufforderungsinformationen ausgeben}Das Verarbeitungsergebnis ist, dass der Ausgang "Teiler kann nicht 0 sein". Java, ein Verarbeitungsmechanismus, der Ausnahmeinformationen nach oben gibt, bildet eine außergewöhnliche Kette.
Die von der Java -Methode ausgelöste prüfbare Ausnahme wird mit der Verarbeitungsfunktion an der Aufrufmethode basierend auf dem Anrufstapel und entlang der Hierarchie des Methodenaufrufs übergeben, und die höchste Ebene ist bis zur Hauptmethode. Wenn die Ausnahme an die Hauptmethode weitergegeben wird, die Hauptvermittlung jedoch nicht in der Lage ist, sie zu handhaben, und die Ausnahme nicht durch die Dürre -Deklaration wirft, kann ein Kompilierungsfehler auftreten.
3) Wenn andere Ausnahmen auftreten, wird das Fang (Ausnahme E) zum Fangen verwendet. Since Exception is the parent class of all exception classes, if the catch (Exception e) code block is placed in front of the other two code blocks, the subsequent code blocks will never be executed, which makes no sense, so the order of catch statements cannot be replaced.
3.4 Throwable类中的常用方法
注意：catch关键字后面括号中的Exception类型的参数e。Exception就是try代码块传递给catch代码块的变量类型，e就是变量名。catch代码块中语句"e.getMessage();"用于输出错误性质。通常异常处理常用3个函数来获取异常的有关信息:
getCause()：返回抛出异常的原因。如果cause 不存在或未知，则返回null。
getMeage()：返回异常的消息信息。
printStackTrace()：对象的堆栈跟踪输出至错误输出流，作为字段System.err 的值。
有时为了简单会忽略掉catch语句后的代码，这样try-catch语句就成了一种摆设，一旦程序在运行过程中出现了异常，就会忽略处理异常，而错误发生的原因很难查找。
5.Java常见异常
在Java中提供了一些异常用来描述经常发生的错误，对于这些异常，有的需要程序员进行捕获处理或声明抛出，有的是由Java虚拟机自动进行捕获处理。Java中常见的异常类:
1. runtimeException子类:
1、 java.lang.ArrayIndexOutOfBoundsException
数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
2、java.lang.ArithmeticException
算术条件异常。譬如：整数除零等。
3、java.lang.NullPointerException
空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等
4、java.lang.ClassNotFoundException
找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。
5、java.lang.NegativeArraySizeException 数组长度为负异常
6、java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常
7、java.lang.SecurityException 安全性异常
8、java.lang.IllegalArgumentException 非法参数异常
2.IOException
IOException：操作输入流和输出流时可能出现的异常。
EOFException 文件已结束异常
FileNotFoundException 文件未找到异常
3. 其他
ClassCastException 类型转换异常类
ArrayStoreException 数组中包含不兼容的值抛出的异常
SQLException 操作数据库异常类
NoSuchFieldException 字段未找到异常
NoSuchMethodException 方法未找到抛出的异常
NumberFormatException 字符串转换为数字抛出的异常
StringIndexOutOfBoundsException 字符串索引超出范围抛出的异常
IllegalAccessException 不允许访问某类异常
InstantiationException 当应用程序试图使用Class类中的newInstance()方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常
6.自定义异常
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。
在程序中使用自定义异常类，大体可分为以下几个步骤。
（1）创建自定义异常类。
（2）在方法中通过throw关键字抛出异常对象。
（3）如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
（4）在出现异常方法的调用者中捕获并处理异常。
在上面的“使用throw抛出异常”例子已经提到了。
Das obige ist der gesamte Inhalt dieses Artikels. Ich hoffe, es wird für das Lernen aller hilfreich sein und ich hoffe, jeder wird Wulin.com mehr unterstützen.