e.printlStackTrack() jdk自带解释学习

 

在异常捕获时,e.printStackTrace()是我们经常遇到的.它究竟print了什么,先从eclipse自带的提示(jdk源码注释)中学习一下:

void java.lang.Throwable.printStackTrace()

Prints this throwable and its backtrace to the standard error stream. This method prints a stack trace for this Throwable object on the error output stream that is the value of the field System.err. The first line of output contains the result of the toString() method for this object. Remaining lines represent data previously recorded by the method fillInStackTrace(). The format of this information depends on the implementation, but the following example may be regarded as typical:

打印出Throwable对象e的堆栈信息:

首行打印出e.toString()信息,

接着打印通过fillInStackTrace()记录的信息(打印格式由实现Throwable的实现方法决定) 9行是 出现异常的地方

6行调用了9行

3行调用了6行

 java.lang.NullPointerException
         at MyClass.mash(MyClass.java:9)
         at MyClass.crunch(MyClass.java:6)
         at MyClass.main(MyClass.java:3)
 

This example was produced by running the program:

 class MyClass {
     public static void main(String[] args) {
3        crunch(null);
     }
     static void crunch(int[] a) {
6         mash(a);
     }
     static void mash(int[] b) {
9         System.out.println(b[0]);
     }
 }
 

The backtrace for a throwable with an initialized, non-null cause should generally include the backtrace for the cause. The format of this information depends on the implementation, but the following example may be regarded as typical:

对于多级异常的抛出,会使用Caused By: 格式来显示异常的由来.

当异常信息含有Cause时,堆栈信息的表示:先列出出现异常的地方,介质一步一步追踪,知道找到最终异常出现的地方.

总结:直接看最后Cause by 语句,即为引起所有异常出现的地方,如本例的最后一个Caused by:为LowLevelException,下面第一个at 即为异常所在的行,本例为30行

 

 HighLevelException: MidLevelException: LowLevelException
         at Junk.a(Junk.java:13)
         at Junk.main(Junk.java:4)
 Caused by: MidLevelException: LowLevelException
         at Junk.c(Junk.java:23)
         at Junk.b(Junk.java:17)
         at Junk.a(Junk.java:11)
         ... 1 more
 Caused by: LowLevelException
         at Junk.e(Junk.java:30)
         at Junk.d(Junk.java:27)
         at Junk.c(Junk.java:21)
         ... 3 more
 

Note the presence of lines containing the characters "...". These lines indicate that the remainder of the stack trace for this exception matches the indicated number of frames from the bottom of the stack trace of the exception that was caused by this exception (the "enclosing" exception). This shorthand can greatly reduce the length of the output in the common case where a wrapped exception is thrown from same method as the "causative exception" is caught. The above example was produced by running the program:

...的含义:

 public class Junk {
     public static void main(String args[]) { 
         try {
             a();
         } catch(HighLevelException e) {
             e.printStackTrace();
         }
     }
     static void a() throws HighLevelException {
         try {
             b();
         } catch(MidLevelException e) {
             throw new HighLevelException(e);
         }
     }
     static void b() throws MidLevelException {
         c();
     }   
     static void c() throws MidLevelException {
         try {
             d();
         } catch(LowLevelException e) {
             throw new MidLevelException(e);
         }
     }
     static void d() throws LowLevelException { 
        e();
     }
     static void e() throws LowLevelException {
         throw new LowLevelException();
     }
 }

 class HighLevelException extends Exception {
     HighLevelException(Throwable cause) { super(cause); }
 }

 class MidLevelException extends Exception {
     MidLevelException(Throwable cause)  { super(cause); }
 }
 
 class LowLevelException extends Exception {
 }