In der Java -Sprache lautet die Basisklasse der Fehlerklasse Java.lang.Error und die Basisklasse der Ausnahmeklasse ist Java.lang.Exception.
1) Ähnlichkeiten: Java.lang.Eror und java.lang.Exception sind beide Unterklassen von Java.lang.Throwable, so dass Java.lang.Eror und Java.lang.Exception selbst und ihre Unterklassen als Objekte des Wurfs verwendet werden können, wie z. B. neue Myerror (); und neue myexception () werfen; Wo die Myerror -Klasse eine Unterklasse von Java.lang.Error ist, und die Myexception -Klasse ist eine Unterklasse von Java.lang.Exception.
2) Unterschiede: Java.lang.Error selbst und seine Unterklassen erfordern nicht die Unterstützung der Versuchserklärung. Die Methode kann jederzeit gemäß der folgenden Methode zurückgegeben werden:
public String myMethod () {thrower New Myerror (); } Wo die MyError -Klasse eine Unterklasse der Java.lang.Error -Klasse ist.
Java.lang.Exception selbst und seine Unterklassen benötigen die Unterstützung von Try-Catch-Anweisungen, und die folgende Methodendefinition ist falsch:
public String myMethod () {thrower New myException (); }Die richtige Methode ist wie folgt definiert:
public String myMethod () löst myException {town myException () aus; }Wo die Myexception -Klasse eine Unterklasse von Java.lang.Exception ist.
Die Java -Ausnahme ist ein Objekt, das erstellt wurde, wenn eine abnormale Situation auftritt, wenn ein Java -Programm ausgeführt wird. Es fasst Ausnahmeinformationen zusammen. Die Wurzelklasse der Java -Ausnahme ist java.lang.throwable. Die gesamte Klasse hat zwei direkte Unterklassen java.lang.Error und java.lang.exception.Error ist ein schwerwiegender Fehler, der vom Programm selbst nicht wiederhergestellt werden kann. Die Ausnahme zeigt einen Ausnahmefehler an, der vom Programm erfasst und verarbeitet werden kann. Der JVM verwendet den Methode Call Stack, um eine Reihe von Methodenaufrufprozessen in jedem Thread zu verfolgen, wodurch die lokalen Informationen jeder aufrufenden Methode gespeichert werden. Bei unabhängigen Java -Programmen kann es bis zur Hauptmethode des Programms. Wenn eine neue Methode aufgerufen wird, platziert das JVM die Stapelstruktur, die die Methode oben im Stapel beschreibt, und die Methode oben im Stapel ist die richtige Ausführungsmethode. Wenn ein j nach der AVA -Methode normal ausgeführt wird, kehrt die JVM aus dem Anrufstapel zur Stapelstruktur der Methode zurück und verarbeitet dann die vorherige Methode weiter. Wenn die Java -Methode während der Ausführung des Codes eine Ausnahme ausgelöst hat, muss der JVM den Catch -Blockcode finden, der die Ausnahme aufnehmen kann. Es prüft zunächst, ob die aktuelle Methode einen solchen Catch -Code -Block hat und ob sie vorhanden ist, und führen Sie den Catch -Code -Block aus. Andernfalls kehrt die JVM zur Stapelstruktur der Methode im Anrufstapel zurück und findet in der vorherigen Methode weiterhin den entsprechenden Catch -Code -Block. Wenn der JVM nach der Main () -Methode, dh, wird die Ausnahme nach der Main () -Methode immer noch nicht gefunden, und der Codeblock für den Ausnahmehandler wird immer noch nicht festgestellt. Wenn der Thread der Haupt -Thread ist, endet die Anwendung auch entsprechend. Zu diesem Zeitpunkt wird der JVM die Ausnahme direkt an den Benutzer übertragen, und die ursprünglichen Ausnahmeinformationen finden Sie am Benutzerterminal.
Java.lang.Throwable Quellcodeanalyse
Paket Java.lang; import Java.io.*; /** * * Throwable is the parent class of all Error and Exceptiong* Note that it has four constructors: * Throwable() * Throwable(String message) * Throwable(Throwable cause) * Throwable(String message, Throwable cause) * */ public class Throwable implements Serializable { private static final long serialVersionUID = -3042686055658047285L; /*** Der native Code spart einen Hinweis auf den Stapel -Backtrac in diesem Steckplatz. */ private transiente Objekt -Backtrace; / *** Informationen, die diese Ausnahme beschreiben*/ private Zeichenfolge DetailMessage; / *** Zeigt an, dass die aktuelle Ausnahme durch das Throwable* verursacht wird* Wenn Null bedeutet, dass die Ausnahme nicht durch andere werfenbare* verursacht wird, wenn dieses Objekt übereinstimmt, zeigt dies an, dass das Objekt, das die Ausnahme verursacht, nicht initialisiert wurde*/ private Throwable Ursache = dies; / *** Array, in dem die Ausnahmestrack beschreibt*/ private stacktraceElement [] stacktrace; / *** Konstruktor, das Ursache -Objekt wird nicht initialisiert werden, kann in Zukunft unter Verwendung von Initcause* fillInstacktrace initialisiert werden, um ein Array seiner Ausnahmestraße zu initialisieren*/ public throwable () {fillInstacktrace (); } /*** Konstruktor* /public Throwable (String -Nachricht) {// Füllen Sie das Ausnahme -Track -Array fillInstacktrace (); // Initialisieren Sie Ausnahmebeschreibung Informationen DetailsMessage = Nachricht; } / *** Konstruktor, Ursache repräsentiert das Ursache Objekt* / public Throwable (String Message, Throwable Cause) {fillInstacktrace (); DetailMessage = Nachricht; this.cause = Ursache; } / *** Konstruktor* / public Throwable (Throwable Cause) {fillInstacktrace (); detailMessage = (cause == null? null: cause.toString ()); this.cause = Ursache; } / *** detaillierte Informationen erhalten* / public String getMessage () {retailedMessage; } / *** detaillierte Informationen erhalten* / public String getLocalizedMessage () {return getMessage (); } / *** das Ursache Objekt erhalten* / public Throwable getCause () {return (cause == this? Null: cause); } /*** Initialisieren Sie das Ursache -Objekt. Diese Methode kann nur einmal ohne Initialisierung aufgerufen werden*/ öffentliches synchronisiertes Throwable Initcause (throwable Ursache) {// Wenn es sich nicht um einen nicht initialisierten Zustand handelt, werfen Sie eine Ausnahme, wenn (this.cause! = This) neue illegale StateException werfen ("kann nicht überschreiben"); // Das zu festgelegte Ursache-Objekt ist gleichmäßig und wirft eine Ausnahme, wenn (Ursache == this) neue IllegalArgumentException ("Selbstverträglichkeit nicht erlaubt"). // das Ursache Objekt this.cause = Ursache; // Rückgabe des SET -Ursache, den Objekt zurückgeben; } / *** String -Darstellung* / public String toString () {String s = getClass (). GetName (); String message = getLocalizedMessage (); return (message! = null)? (s + ":" + meldung): s; } / *** Drucken Sie die Fehlerspur aus* / public void printStacktrace () {printStacktrace (System.err); } /*** Drucken Sie die Fehlerspur aus* /public void printStacktrace (printstream s) {synchronisiert (s) {// Aufrufen der TOString -Methode des aktuellen Objekts S.println (this); // Erhalten Sie die Ausnahme -Track -Array -StacktraceElement [] Trace = getourstacktrace (); // Drucken Sie die String -Darstellung jedes Elements für (int i = 0; i <trece.length; i ++) s.println aus ("/tat"+Trace [i]); // das Ursache Objekt throwable ourcause = getCause () erhalten; // Drucken Sie die Informationen des Ursache Objekt rekursiv aus, wenn (Ourcause! = NULL) orcause.printstacktraceascause (s, Trace); }} /*** Drucken Sie die Ursache -Objektinformationen* @param s gedruckter Stream* @param verursachte Ausnahme -Track mit Ausnahme, die durch dieses Objekt verursacht wurden // m ist das letzte Element des aktuellen Ausnahmestrack-Arrays, // n ist das letzte Element des Ausnahmestrack-Arrays der Ausnahme, die durch das aktuelle Objekt int m = trece.Length-1, n = ERIGTETRACE.Length-1 verursacht wird; // Schleife hinter den beiden Arrays. Wenn es gleich ist, schleifen Sie die Ungleichheit oder das Array den Anfang, während (m> = 0 && n> = 0 && Trace [m] .Eequals (verursacht [n]) {m-; N--; } // Die gleiche Zahl int rampesingmon = trece.length - 1 - m; // Verschiedene Fehlerspuren ausdrucken s.println ("verursacht von:" + this); für (int i = 0; i <= m; i ++) s.println ("/tat"+Trace [i]); // Wenn es dieselbe Zahl gibt, drucken Sie dieselbe Zahl aus, wenn (Framessing! // Erhalten Sie die Ursache dieses Objekts und drucken Sie die Informationen rekursiv aus, weil wir ca. getcause () rekursiv geworfen werden. if (Ourcase! } / *** Drucken Sie die Fehlerspur aus* / public void printStacktrace (Printwriter s) {synchronisiert (s) {s.println (this); StackTraceElement [] Trace = getourstacktrace (); für (int i = 0; i <trece.length; i ++) s.println ("/tat"+Trace [i]); Throwable Ourcause = getCause (); if (Ourcase! }} / *** Drucken Sie die Informationen zum Ursache Objekt* / private void printStacktraceAscause (Printwriter S, StacktraceElement [] ERIDTETRACE) {// Assert thread.oldslock (s); // Die Anzahl von Frames gemeinsam zwischen diesem und stacktraceElement [] trace = getourstacktrace () verursacht; int M = Trace.Length-1, n = verursacht. Length-1; while (m> = 0 && n> = 0 && trace [m] .equals (verursachtesTrace [n])) {m--; N--; } int Framsincommon = Trace.Length - 1 - m; S. println ("verursacht von:" + this); für (int i = 0; i <= m; i ++) s.println ("/tat"+Trace [i]); if (Framessing! // wiederholen, wenn wir einen Ursache throwable ourcausses = getCause () haben; if (Ourcase! } / *** füllen Sie die Ausnahmespur aus* / public synchronisierte native Throwable FillinStacktrace (); / *** Gibt eine Kopie des aktuellen Ausnahmestracks zurück. } /** * Erhalten Sie den aktuellen Ausnahmestrack. // Erstellen Sie ein neues Ausnahmemittel -Tracks und füllen Sie es stacktrace = new stacktraceElement [Tiefe]; für (int i = 0; i <tiefe; i ++) stacktrace [i] = getStacktraceElement (i); // Erhalten Sie die Ausnahmestraße des angegebenen Bitpunkts} return stacktrace; } /*** Setzen Sie Ausnahmestrack* /public void setStackTrace (StackTraceElement [] Stacktrace) {// Die Einstellung Parameter stacktraceElement [] DefendenSiveCopy = (StackTraceElement []) stacktrace.clone (); // Wenn der Einstellungsparameter leere Elemente hat, wird eine Ausnahme für (int i = 0; i <defensivecopy.length; i ++) geworfen, wenn (defensiveCopy [i] == null) neue nullPointerexception ("StackTrace [" + i + "] werfen); // Setzen Sie die Ausnahmemittel des aktuellen Objekts. } / ** * Die Tiefe der Ausnahmespur, 0 bedeutet, dass es nicht möglich ist, * / private native int GetStacktracedepth () zu erhalten; / *** Erhalten Sie die Ausnahmespur des angegebenen Bitpunkts*/ Private native stacktraceElement getStacktraceElement (int Index); private synchronisierte void writeObject (java.io.objectoutputStream s) löst ioException {getourstacktrace () aus; S.DefaultWriteObject (); }}