En el idioma Java, la clase base de la clase de error es java.lang.error, y la clase base de la clase de excepción es java.lang.exception.
1) Similidades: java.lang.error y java.lang.exception son subclases de java.lang.throwable, por lo que java.lang.error y java.lang.exception mismos y sus subclases pueden usarse como objetos de lanzamiento, como: tirar nueva myerror (); y tirar nueva myException (); donde, la clase MyError es una subclase de java.lang.error, y la clase MyException es una subclase de java.lang.exception.
2) Diferencias: Java.lang.Error en sí y sus subclases no requieren el soporte de la declaración Try-Catch. El método se puede devolver en cualquier momento, según lo definido por el siguiente método:
public String mymethod () {Throw New MyError (); } Donde la clase MyError es una subclase de Java.Lang.Error Clase.
java.lang.Exception en sí y sus subclases necesitan el soporte de las declaraciones de captura de prueba, y la siguiente definición del método es incorrecta:
public String mymethod () {Throw New MyException (); }El método correcto se define de la siguiente manera:
public String mymethod () lanza myException {lanzar nueva myException (); }Donde la clase de MyException es una subclase de java.lang.Exception.
La excepción de Java es un objeto creado cuando se encuentra una situación anormal cuando se ejecuta un programa Java. Encapsula información de excepción. La clase raíz de la excepción de Java es java.lang.throwable. Toda la clase tiene dos subclases directos java.lang.error y java.lang.exception.Error es un error grave que el programa mismo no puede recuperar. La excepción indica un error de excepción que el programa puede atrapar y procesar. El JVM utiliza la pila de llamadas de método para rastrear una serie de procesos de llamadas de métodos en cada hilo, que guarda la información local de cada método de llamadas. Para programas Java independientes, puede todo el camino al método principal del programa. Cuando se llama a un nuevo método, el JVM coloca la estructura de la pila que describe el método en la parte superior de la pila, y el método en la parte superior de la pila es el método de ejecución correcto. Cuando A J después del método AVA se ejecuta normalmente, el JVM regresa a la estructura de pila del método desde la pila de llamadas, y luego continúa procesando el método anterior. Si el método Java lanza una excepción durante la ejecución del código, el JVM debe encontrar el código de bloque Catch que puede captar la excepción. Primero verifica si el método actual tiene dicho bloque de código de captura, y si existe, ejecute el bloque de código de captura. De lo contrario, el JVM regresa a la estructura de la pila del método en la pila de llamadas, y continúa encontrando el bloque de código de captura apropiado en el método anterior. Finalmente, si el JVM persigue al método Main (), es decir, sigue lanzando la excepción al método Main () y aún no ha encontrado el bloque de código para el controlador de excepciones, el hilo terminará anormalmente. Si el hilo es el hilo principal, la aplicación también terminará en consecuencia. En este momento, el JVM lanzará la excepción directamente al usuario, y la información de excepción original se verá en el terminal del usuario.
Java.lang. Análisis del código fuente de Throwable
paquete java.lang; import java.io.*; / ** * * Throwable es la clase principal de todos los errores y excepcionistas * Tenga en cuenta que tiene cuatro constructores: * showleable () * showable (mensaje de cadena) * throwable (causa de lanzamiento) * throwable (mensaje de cadena, causa de lanzamiento) * */ public classable implementa serializable {private static final SerialverSionUid = -304268605555558047285l; /*** El código nativo guarda alguna indicación de la trama de pila en esta ranura. */ Transitorio privado de objeto transitorio Backtrace; / *** Información que describe esta excepción*/ String private DetalleMessage; / *** indica que la excepción actual es causada por el lanzamiento* Si nulo significa que la excepción no es causada por otros lanzables* Si este objeto es el mismo que en sí mismo, indica que el objeto que causa la excepción no se ha inicializado*/ causa de lanzamiento privado = this; / *** Array que describe la pista de excepción*/ private StackTraceElement [] stacktrace; / *** Constructor, el objeto Cause no se inicializa en el futuro utilizando initcause* FillInStackTrace se puede usar para inicializar una matriz de sus pistas de excepción*/ public shoseable () {FillInStackTrace (); } /*** constructor* /public shrowable (mensaje de cadena) {// Llena la matriz de excepción de la pista FillinStackTrace (); // Inicializar la excepción Descripción Información DetallessMessage = Mensaje; } / *** constructor, causa representa el objeto Cause* / public showable (mensaje de cadena, causa de lanzamiento) {FillInStackTrace (); DetellMessage = Mensaje; this.Cause = causa; } / *** constructor* / public showable (causa de lanzamiento) {fillinStackTrace (); detallMessage = (causa == nulo? NULL: Cause.ToString ()); this.Cause = causa; } / *** Obtenga información detallada* / public String getMessage () {return detalledMessage; } / *** Obtenga información detallada* / public String getLocalizedMessage () {return getMessage (); } / *** Obtenga el objeto Cause* / public showleable getCause () {return (causa == this? Null: causa); } /*** Inicializar el objeto Cause. Este método solo se puede llamar una vez sin inicialización*/ public sincronizado initvable initCause (causa de lanzamiento) {// Si no es un estado no inicializado, arroje una excepción si (this. // El objeto de causa que se establece es igual a sí mismo y arroja una excepción si (causa == esto) arroja una nueva IllegalArgumentException ("autocavimentación no permitida"); // Establecer el objeto Cause este.Cause = Cause; // devuelve el objeto de causa establecida Devuelve esto; } / *** Representación de cadena* / public String toString () {String s = getClass (). GetName (); String Message = getLocalizedMessage (); return (mensaje! = nulo)? (S + ":" + Mensaje): S; } / *** Imprima la pista de error* / public void printStackTrace () {printStackTrace (System.err); } /*** Imprima la pista de error* /public void printStackTrace (printstream s) {sincronizado (s) {// llamando al método tostring del objeto actual s.println (this); // Obtenga la matriz de excepción StackTraceElement [] traza = getourStackTrace (); // Imprima la representación de cadena de cada elemento para (int i = 0; i <trace.length; i ++) s.println ("/tat"+trace [i]); // Obtenga el objeto Cause lanzable nuestroCause = getCause (); // Imprima recursivamente la información del objeto Cause if (ourCause! = NULL) OurCause.PrintStackTRaceaseCause (S, Trace); }} /*** Imprima la información de objeto Cause* @param s transmisión impresa* @param Casea de excepción causada con excepción causada por este objeto* /private void printStackTRaceaseCause (printStream s, stackTaceElement [] causado) {// Obtenga la excepción actual de la excepción stacktaceElement [] traza = getourStackTrace (); // m es el último elemento de la matriz de pista de excepción actual, // n es el último elemento de la matriz de pista de excepción de la excepción causada por el objeto actual int m = trace.length-1, n = wealTrace.length-1; // bucle desde detrás de las dos matrices respectivamente. Si es igual, bucle hasta que la desigualdad o la matriz lleguen al principio mientras (m> = 0 && n> = 0 && traza [m] .equals (causeTrace [n])) {m--; norte--; } // el mismo número int FramesIncommon = Trace.length - 1 - m; // Imprima diferentes trazas de error S.Println ("causado por:" + esto); para (int i = 0; i <= m; i ++) s.println ("/tat"+traza [i]); // Si hay el mismo número, imprima el mismo número si (FramesIncommon! = 0) S.Println ("/t ..." + FramesIncommon + "More"); // Obtenga la causa de este objeto e imprima la información que se puede lanzar recursivamente nuestro Cause = getCause (); if (ourCause! = NULL) ourCause.PrintStackTRaceaseCause (s, traza); } / *** Imprima la pista de error* / public void printStacktrace (printWriter s) {sincronizado (s) {s.println (this); StackTraceElement [] traza = getourStackTrace (); para (int i = 0; i <trace.length; i ++) s.println ("/tat"+trace [i]); Lanzable nuestroCause = getCause (); if (ourCause! = NULL) ourCause.PrintStackTRaceaseCause (s, traza); }} / *** Imprima la información sobre el objeto Cause* / private void printStackTRaceaseCause (printWriter s, stackTraceElement [] causeTrace) {// afirmar thread.holdSlock (s); // Calcule el número de marcos en común entre esto y causó StackTraCeElement [] traza = getourStackTrace (); int m = trace.length-1, n = causeTrace.length-1; while (m> = 0 && n> = 0 && traza [m] .equals (causeTrace [n])) {m--; norte--; } int FramesIncommon = trace.length - 1 - m; S.println ("causado por:" + esto); para (int i = 0; i <= m; i ++) s.println ("/tat"+traza [i]); if (FramesIncommon! = 0) S.Println ("/t ..." + FramesIncommon + "más"); // recurrir si tenemos una causa que se puede tirar a Ourcauses = getCause (); if (ourCause! = NULL) ourCause.PrintStackTRaceaseCause (s, traza); } / *** Completa la pista de excepción* / public synchronized national lanzar fillinStackTrace (); / *** Devuelve una copia de la pista de excepción actual*/ public stackTraceElement [] getStackTrace () {return (stackTraceElement []) getourStackTrace (). Clone (); } /** * Obtenga la pista de excepción actual * /private sincronizado stackTraceElement [] getourStackTrace () {// Si este método se llama por primera vez, la matriz de la pista de excepción se inicializa si (stackTrace == null) {// obtiene la profundidad de excepción de la excepción = getStackAphAphth (); // Cree una nueva variedad de pistas de excepción y lléntelo stackTrace = new StackTraceElement [profundidad]; para (int i = 0; i <profundidad; i ++) stacktrace [i] = getStackTraceElement (i); // Obtenga la pista de excepción del punto de bit especificado} return StackTrace; } /*** Establezca la pista de excepción* /public void setstackTrace (stackTraceElement [] stackTrace) {// Copiar el parámetro de configuración StackTraceElement [] defendensivecopy = (stacktraceElement []) stacktrace.clone (); // Si el parámetro de configuración tiene elementos vacíos, se lanzará una excepción para (int i = 0; i <defensivecopy.length; i ++) if (defensivecopy [i] == null) tirar nueva nullPointerException ("Stacktrace [" + i + "]"); // establece la pista de excepción del objeto actual este.stacktrace = defensivecopy; } / ** * La profundidad de la pista de excepción, 0 significa que no es posible obtener * / Private Native int getStackTraCedEpth (); / *** Obtenga la pista de excepción del punto de bit especificado*/ privado stackTraceElement getStackTraceElement (int index); Private sincronizado void writeObject (java.io.objectOutputStream s) lanza ioexception {getourStackTrace (); S.DefaultWriteObject (); }}