Dans la langue java, la classe de base de la classe d'erreur est java.lang.error, et la classe de base de la classe d'exception est java.lang.exception.
1) similitudes: java.lang.error et java.lang.Exception sont les deux sous-classes de java.lang.throwable, donc java.lang.error et java.lang.exception eux-mêmes et leurs sous-classes peuvent être utilisées comme objets de lancer, comme: lancer de nouveaux MyError (); et lancer une nouvelle MyException (); Où, la classe Myerror est une sous-classe de java.lang.error, et la classe MyException est une sous-classe de java.lang.exception.
2) Différences: java.lang.error lui-même et ses sous-classes ne nécessitent pas la prise en charge de l'instruction TRY-Catch. La méthode peut être retournée à tout moment, telle que définie par la méthode suivante:
String public MyMethod () {Throw New MyError (); } Où la classe MyError est une sous-classe de la classe java.lang.error.
Java.lang.Exception elle-même et ses sous-classes ont besoin de prendre en charge les instructions de couple d'essai, et la définition de la méthode suivante est erronée:
public String myMethod () {Throw new MyException (); }La méthode correcte est définie comme suit:
public String myMethod () lève MyException {Throw new MyException (); }Où la classe MyException est une sous-classe de java.lang.exception.
L'exception Java est un objet créé lorsqu'une situation anormale est rencontrée lorsqu'un programme Java est en cours d'exécution. Il résume les informations d'exception. La classe racine de l'exception Java est java.lang.throwable. La classe entière a deux sous-classes directes java.lang.error et java.lang.exception.error est une erreur grave qui ne peut pas être récupérée par le programme lui-même. L'exception indique une erreur d'exception qui peut être capturée et traitée par le programme. Le JVM utilise la pile d'appels de méthode pour suivre une série de processus d'appel de méthode dans chaque thread, ce qui enregistre les informations locales de chaque méthode d'appel. Pour les programmes Java indépendants, il peut jusqu'à la méthode principale du programme. Lorsqu'une nouvelle méthode est appelée, le JVM place la structure de la pile décrivant la méthode en haut de la pile, et la méthode en haut de la pile est la méthode d'exécution correcte. Lorsqu'un J après l'exécution de la méthode AVA normalement, le JVM revient à la structure de pile de la méthode à partir de la pile d'appels, puis continue de traiter la méthode précédente. Si la méthode Java lance une exception lors de l'exécution du code, le JVM doit trouver le code de bloc Catch qui peut attraper l'exception. Il vérifie d'abord si la méthode actuelle a un tel bloc de code de capture et, s'il existe, exécutez le bloc de code de capture. Sinon, le JVM revient à la structure de pile de la méthode à la pile d'appels et continue de trouver le bloc de code de capture approprié dans la méthode précédente. Enfin, si le JVM passe jusqu'à la méthode Main (), c'est-à-dire qu'il continue de lancer l'exception à la méthode principale (), et n'a toujours pas trouvé le bloc de code pour le gestionnaire d'exception, le thread se terminera anormalement. Si le thread est le thread principal, l'application se terminera également en conséquence. À l'heure actuelle, le JVM lancera l'exception directement à l'utilisateur, et les informations d'exception d'origine seront visibles sur le terminal utilisateur.
Java.lang.Analyse du code source lancé
Package Java.lang; importer java.io. *; / ** * * Throwable est la classe parent de toutes les erreurs et exceptiong * note qu'il a quatre constructeurs: * throwable () * throwable (message de chaîne) * Throwable (Cause thrownable) * Throwable (message de chaîne, cause thordivable) * * / classe publique Throwable implémenable sérialisable {private static final SerialVeesionuid = -304266055658047285l; / ** * Le code natif enregistre une indication de la backtrace de pile dans cette fente. * / Backtrace d'objet transitoire privé; / ** * Informations décrivant cette exception * / String privé DetailMessage de chaîne; / ** * Indique que l'exception actuelle est causée par le jetable * Si NULL signifie que l'exception n'est pas causée par d'autres lanceurs * Si cet objet est le même que lui-même, il indique que l'objet provoquant l'exception n'a pas été initialisé * / Cause lancable privée = ceci; / ** * Array décrivant la piste d'exception * / stackTraceElement privé [] stackTrace; / ** * Constructeur, l'objet de cause n'est pas initialisé peut être initialisé à l'avenir en utilisant initcause * FillinStackTrace peut être utilisé pour initialiser un tableau de ses pistes d'exception * / public throwable () {FILLINSTACKTRACE (); } / ** * Constructeur * / public throwable (String Message) {// Remplissez le tableau d'exception Track FillinStackTrace (); // Initialiser l'exception Description Détails des informations = message; } / ** * Constructeur, la cause représente l'objet de cause * / publique lancé (message de chaîne, cause thrognable) {FILLINSTACKTRACE (); DetailMessage = Message; this.cause = cause; } / ** * Constructeur * / public throwable (cause thrognable) {fillInstackTrace (); DetailMessage = (cause == null? null: cause.toString ()); this.cause = cause; } / ** * Obtenez des informations détaillées * / public String getMessage () {return De détailléSage; } / ** * Obtenez des informations détaillées * / chaîne publique getLocalizedMessage () {return getMessage (); } / ** * Obtenez l'objet de cause * / public thrownable getCause () {return (cause == this? Null: cause); } / ** * Initialisez l'objet de cause. Cette méthode ne peut être appelée une seule fois sans initialisation * / public synchronisé throwable initcause (cause thrognable) {// Si ce n'est pas un état non initialisé, lancez une exception si (ce.cause! = This) Jetez un nouveau nouveau IlgalStateException ("Impossible d'écraser la cause"); // L'objet de cause à définir est égal à lui-même et lance une exception si (cause == ceci) jetez un nouveau IllégalArgumentException ("auto-augure non autorisée"); // Définit l'objet de cause this.cause = cause; // Renvoie l'objet Set Cause Retour; } / ** * représentation de chaîne * / public String toString () {String S = getClass (). GetName (); Message de chaîne = getLocalizedMessage (); return (message! = null)? (s + ":" + message): s; } / ** * Imprimez la piste d'erreur * / public void printstackTrace () {printStackTrace (System.err); } / ** * Imprimez la piste d'erreur * / public void printstackTrace (printStream s) {synchronisé (s) {// appelant la méthode toString de l'objet actuel s.println (this); // Obtenez le tableau d'exception de piste stackTraceElement [] trace = getOrStackTrace (); // imprime la représentation de chaîne de chaque élément pour (int i = 0; i <trace.length; i ++) s.println ("/ tat" + trace [i]); // Obtenez l'objet de cause Throwable OurCause = getCause (); // Imprimez récursivement les informations de l'objet de cause if (ourcause! = Null) OurCause.printStackTraceascause (s, trace); }} / ** * Imprimez les informations sur les objets de cause * @param s Stream imprimé * @param BalseTrace Exception Track avec exception causée par cet objet * / private void printstackTraceascause (PrintStream S, stackTraceElement [] CausorStackTrace); // m est le dernier élément du tableau de piste d'exception actuel, // n est le dernier élément du tableau d'exception de la piste de l'exception causée par l'objet actuel int m = trace.length-1, n = causalTrace.length-1; // boucle derrière les deux tableaux respectivement. S'il est égal, boucle jusqu'à l'inégalité ou que le tableau atteint le début while (m> = 0 && n> = 0 && trace [m] .equals (causalTrace [n])) {m--; n--; } // Le même nombre int FramesInCommon = Trace.length - 1 - m; // imprime différentes traces d'erreur s.println ("causées par:" + ceci); pour (int i = 0; i <= m; i ++) s.println ("/ tat" + trace [i]); // S'il y a le même numéro, imprimez le même numéro si (FramesInCommon! = 0) S.println ("/ t ..." + FramesInCommon + "More"); // Obtenez la cause de cet objet et imprimez les informations récursives Thrownable OurCause = GetCause (); if (ourcause! = null) ourcause.printstackTraceascause (s, trace); } / ** * Imprimez la piste d'erreur * / public void printstackTrace (printwriter s) {synchronisé (s) {s.println (this); StackTraceElement [] trace = getOrStackTrace (); for (int i = 0; i <trace.length; i ++) s.println ("/ tat" + trace [i]); Throwable OurCause = getCause (); if (ourcause! = null) ourcause.printstackTraceascause (s, trace); }} / ** * Imprimez les informations sur l'objet de cause * / private void printstackTraceascause (printwriter s, stackTraceElement [] causalTrace) {// affirmer thread.holdslock (s); // Calculez le nombre de trames en commun entre cela et a provoqué StackTraceElement [] trace = getOrStackTrace (); int m = trace.length-1, n = causalTrace.length-1; while (m> = 0 && n> = 0 && trace [m] .equals (causalTrace [n])) {m--; n--; } int FramesInCommon = trace.length - 1 - m; S.println ("causé par:" + ceci); pour (int i = 0; i <= m; i ++) s.println ("/ tat" + trace [i]); if (FramesInCommon! = 0) s.println ("/ t ..." + FramesInCommon + "More"); // Recurse si nous avons une cause OurCauses lancinables = getCause (); if (ourcause! = null) ourcause.printstackTraceascause (s, trace); } / ** * Remplissez la piste d'exception * / public synchronisé natif lance-filliinstackTrace (); / ** * Renvoie une copie de la piste d'exception actuelle * / public stackTraceElement [] getStackTrace () {return (stackTraceElement []) getOrStackTrace (). Clone (); } / ** * Obtenez la piste d'exception actuelle * / private synchronisé stackTraceElement [] getOrStackTrace () {// Si cette méthode est appelée pour la première fois, le tableau d'exception de piste est initialisé if (stackTrace == NULL) {// Obtenez le Depth de Defth de l'exception intro Depth = GetStackTracePH (); // Créez un nouveau tableau de pistes d'exception et remplissez-la stackTrace = new StackTraceElement [Depth]; pour (int i = 0; i <defth; i ++) stackTrace [i] = getStackTraceElement (i); // Obtenez la piste d'exception du point de bit spécifié} return stackTrace; } / ** * Définir Exception Track * / public void setStackTrace (stackTraceElement [] stackTrace) {// Copiez le paramètre de réglage stackTraceElement [] DefendeSiveCopy = (stackTraceElement []) stackTrace.clone (); // Si le paramètre de réglage a des éléments vides, une exception sera lancée pour (int i = 0; i <defensiveCopy.length; i ++) if (DefenSiveCopy [i] == null) lancez une nouvelle nullpointerException ("stackTrace [" + i + "]"); // Définit la piste d'exception de l'objet actuel this.stackTrace = DefenSiveCopy; } / ** * La profondeur de la piste d'exception, 0 signifie qu'il n'est pas possible d'obtenir * / natif privé int getStackTracePth (); / ** * Obtenez la piste d'exception du point de bits spécifié * / stackTraceElement natif privé GetStackTraceElement (int index); private synchronisé void writeObject (java.io.objectOutputStream s) lève ioException {getOrStackTrace (); S.DefaultWriteObject (); }}