欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

解析Java中所有错误和异常的父类java.lang.Throwable

程序员文章站 2024-03-09 17:10:05
在java语言中,错误类的基类是java.lang.error,异常类的基类是java.lang.exception。 1)相同点:java.lang.error和ja...

在java语言中,错误类的基类是java.lang.error,异常类的基类是java.lang.exception。
1)相同点:java.lang.error和java.lang.exception都是java.lang.throwable的子类,因此java.lang.error和java.lang.exception自身及其子类都可以作为throw的使用对象,如:throw new myerror();和throw new myexception();其中,myerror类是java.lang.error的子类,myexception类是java.lang.exception的子类。
2)不同点:java.lang.error自身及其子类不需要try-catch语句的支持,可在任何时候将返回方法,如下面的方法定义:

public string mymethod() { 
throw new myerror(); 
} 

其中myerror类是java.lang.error类的子类。
java.lang.exception自身及其子类需要try-catch语句的支持,如下的方法定义是错误的:

public string mymethod() { 
throw new myexception(); 
} 

正确的方法定义如下:

public string mymethod() throws myexception { 
throw new myexception(); 
} 

其中myexception类是java.lang.exception的子类。

java异常是在java程序运行的时候遇到非正常的情况而创建的对象,它封装了异常信息,java异常的根类为java.lang.throwable,整个类有两个直接子类java.lang.error和java.lang.exception.error是程序本身无法恢复的严重错误.exception则表示可以被程序捕获并处理的异常错误.jvm用方法调用栈来跟踪每个线程中一系列的方法调用过程,该栈保存了每个调用方法的本地信息.对于独立的java程序,可以一直到该程序的main方法.当一个新方法被调用的时候,jvm把描述该方法的栈结构置入栈顶,位于栈顶的方法为正确执行的方法.当一个java方法正常执行完毕,jvm回从调用栈中弹处该方法的栈结构,然后继续处理前一个方法.如果java方法在执行代码的过程中抛出异常,jvm必须找到能捕获异常的catch块代码.它首先查看当前方法是否存在这样的catch代码块,如果存在就执行该 catch代码块,否则jvm回调用栈中弹处该方法的栈结构,继续到前一个方法中查找合适的catch代码块.最后如果jvm向上追到了main()方法,也就是一直把异常抛给了main()方法,仍然没有找到该异常处理的代码块,该线程就会异常终止,如果该线程是主线程,应用程序也随之终止,此时 jvm将把异常直接抛给用户,在用户终端上会看到原始的异常信息.

java.lang.throwable源代码解析

package java.lang; 
import java.io.*; 
/** 
* 
* throwable是所有error和exceptiong的父类 
* 注意它有四个构造函数: 
* throwable() 
* throwable(string message) 
* throwable(throwable cause) 
* throwable(string message, throwable cause) 
* 
*/ 
public class throwable implements serializable { 
  private static final long serialversionuid = -3042686055658047285l; 
 
  /** 
  * native code saves some indication of the stack backtrace in this slot. 
  */ 
  private transient object backtrace; 
 
  /** 
  * 描述此异常的信息 
  */ 
  private string detailmessage; 
 
  /** 
  * 表示当前异常由那个throwable引起 
  * 如果为null表示此异常不是由其他throwable引起的 
  * 如果此对象与自己相同,表明此异常的起因对象还没有被初始化 
  */ 
  private throwable cause = this; 
 
  /** 
  * 描述异常轨迹的数组 
  */ 
  private stacktraceelement[] stacktrace; 
 
  /** 
  * 构造函数,起因对象没有被初始化可以在以后使用initcause进行初始化 
  * fillinstacktrace可以用来初始化它的异常轨迹的数组 
  */ 
  public throwable() { 
   fillinstacktrace(); 
  } 
 
  /** 
  * 构造函数 
  */ 
  public throwable(string message) { 
   //填充异常轨迹数组 
   fillinstacktrace(); 
   //初始化异常描述信息 
   detailmessage = message; 
  } 
 
  /** 
  * 构造函数,cause表示起因对象 
  */ 
  public throwable(string message, throwable cause) { 
   fillinstacktrace(); 
   detailmessage = message; 
   this.cause = cause; 
  } 
 
  /** 
  * 构造函数 
  */ 
  public throwable(throwable cause) { 
   fillinstacktrace(); 
   detailmessage = (cause==null ? null : cause.tostring()); 
   this.cause = cause; 
  } 
 
  /** 
  * 获取详细信息 
  */ 
  public string getmessage() { 
   return detailmessage; 
  } 
 
  /** 
  * 获取详细信息 
  */ 
  public string getlocalizedmessage() { 
   return getmessage(); 
  } 
 
  /** 
  * 获取起因对象 
  */ 
  public throwable getcause() { 
   return (cause==this ? null : cause); 
  } 
 
  /** 
  * 初始化起因对象,这个方法只能在未被初始化的情况下调用一次 
  */ 
  public synchronized throwable initcause(throwable cause) { 
   //如果不是未初始化状态则抛出异常 
   if (this.cause != this) 
    throw new illegalstateexception("can't overwrite cause"); 
   
   //要设置的起因对象与自身相等则抛出异常 
   if (cause == this) 
    throw new illegalargumentexception("self-causation not permitted"); 
   
   //设置起因对象 
   this.cause = cause; 
   //返回设置的起因的对象 
   return this; 
  } 
 
  /** 
  * 字符串表示形式 
  */ 
  public string tostring() {  
   string s = getclass().getname();   
   string message = getlocalizedmessage();  
   return (message != null) ? (s + ": " + message) : s; 
  } 
 
  /** 
  * 打印出错误轨迹 
  */ 
  public void printstacktrace() { 
   printstacktrace(system.err); 
  } 
 
  /** 
  * 打印出错误轨迹 
  */ 
  public void printstacktrace(printstream s) { 
   synchronized (s) { 
   //调用当前对象的tostring方法 
    s.println(this); 
   //获取异常轨迹数组 
    stacktraceelement[] trace = getourstacktrace(); 
    
   //打印出每个元素的字符串表示 
    for (int i=0; i < trace.length; i++) 
    s.println("\tat " + trace[i]); 
 
   //获取起因对象 
    throwable ourcause = getcause(); 
    
   //递归的打印出起因对象的信息 
    if (ourcause != null) 
    ourcause.printstacktraceascause(s, trace); 
   } 
  } 
 
  /** 
  * 打印起因对象的信息 
  * @param s 打印的流 
  * @param causedtrace 有此对象引起的异常的异常轨迹 
  */ 
  private void printstacktraceascause(printstream s, 
           stacktraceelement[] causedtrace) 
  { 
   //获得当前的异常轨迹 
   stacktraceelement[] trace = getourstacktrace(); 
   //m为当前异常轨迹数组的最后一个元素位置, 
   //n为当前对象引起的异常的异常轨迹数组的最后一个元素 
   int m = trace.length-1, n = causedtrace.length-1; 
   //分别从两个数组的后面做循环,如果相等则一直循环,直到不等或数组到头 
   while (m >= 0 && n >=0 && trace[m].equals(causedtrace[n])) { 
    m--; n--; 
   } 
   
   //相同的个数 
   int framesincommon = trace.length - 1 - m; 
   
   //打印出不同的错误轨迹 
   s.println("caused by: " + this); 
   for (int i=0; i <= m; i++) 
    s.println("\tat " + trace[i]); 
   //如果有相同的则打印出相同的个数 
   if (framesincommon != 0) 
    s.println("\t... " + framesincommon + " more"); 
 
   //获得此对象的起因对象,并递归打印出信息 
   throwable ourcause = getcause(); 
   if (ourcause != null) 
    ourcause.printstacktraceascause(s, trace); 
  } 
 
  /** 
  * 打印出错误轨迹 
  */ 
  public void printstacktrace(printwriter s) { 
   synchronized (s) { 
    s.println(this); 
    stacktraceelement[] trace = getourstacktrace(); 
    for (int i=0; i < trace.length; i++) 
     s.println("\tat " + trace[i]); 
 
    throwable ourcause = getcause(); 
    if (ourcause != null) 
     ourcause.printstacktraceascause(s, trace); 
   } 
  } 
 
  /** 
  * 打印起因对象的信息 
  */ 
  private void printstacktraceascause(printwriter s, 
           stacktraceelement[] causedtrace) 
  { 
   // assert thread.holdslock(s); 
 
   // compute number of frames in common between this and caused 
   stacktraceelement[] trace = getourstacktrace(); 
   int m = trace.length-1, n = causedtrace.length-1; 
   while (m >= 0 && n >=0 && trace[m].equals(causedtrace[n])) { 
    m--; n--; 
   } 
   int framesincommon = trace.length - 1 - m; 
 
   s.println("caused by: " + this); 
   for (int i=0; i <= m; i++) 
    s.println("\tat " + trace[i]); 
   if (framesincommon != 0) 
    s.println("\t... " + framesincommon + " more"); 
 
   // recurse if we have a cause 
   throwable ourcause = getcause(); 
   if (ourcause != null) 
    ourcause.printstacktraceascause(s, trace); 
  } 
 
  /** 
  * 填充异常轨迹 
  */ 
  public synchronized native throwable fillinstacktrace(); 
 
  /** 
  * 返回当前的异常轨迹的拷贝 
  */ 
  public stacktraceelement[] getstacktrace() { 
   return (stacktraceelement[]) getourstacktrace().clone(); 
  } 
 
  
  /** 
  * 获取当前的异常轨迹 
  */ 
  private synchronized stacktraceelement[] getourstacktrace() { 
   //如果第一次调用此方法则初始化异常轨迹数组 
   if (stacktrace == null) { 
   //获得异常轨迹深度 
    int depth = getstacktracedepth(); 
   //创建新的异常轨迹数组,并填充它 
    stacktrace = new stacktraceelement[depth]; 
    
   for (int i=0; i < depth; i++) 
    stacktrace[i] = getstacktraceelement(i);//获取指定位标的异常轨迹 
   } 
   
   return stacktrace; 
  } 
 
  /** 
  * 设置异常轨迹 
  */ 
  public void setstacktrace(stacktraceelement[] stacktrace) { 
   //拷贝设置参数 
   stacktraceelement[] defensivecopy = 
    (stacktraceelement[]) stacktrace.clone(); 
   
   //如果设置参数有空元素则抛出异常 
   for (int i = 0; i < defensivecopy.length; i++) 
    if (defensivecopy[i] == null) 
     throw new nullpointerexception("stacktrace[" + i + "]"); 
 
   //设置当前对象的异常轨迹 
   this.stacktrace = defensivecopy; 
  } 
 
  /** 
  * 异常轨迹的深度,0表示无法获得 
  */ 
  private native int getstacktracedepth(); 
 
  /** 
  * 获取指定位标的异常轨迹 
  */ 
  private native stacktraceelement getstacktraceelement(int index); 
 
  
  private synchronized void writeobject(java.io.objectoutputstream s) 
   throws ioexception 
  { 
   getourstacktrace(); 
   s.defaultwriteobject(); 
  } 
}