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

这篇文章主要介绍了Java中所有错误和异常的父类java.lang.Throwable,文章中简单地分析了其源码,说明在代码注释中,需要的朋友可以参考下

在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(); 
  } 
} 

以下讲述的是平时遇到的，比较常见的具体异常情况，跟上面有部分重复：

Throwable是所有异常的根，java.lang.Throwable

Error是错误，java.lang.Error

Exception是异常，java.lang.Exception

Throwable： 有两个重要的子类：Exception（异常）和 Error（错误），二者都是 Java 异常处理的重要子类，各自都包含大量子类。

Error（错误）:是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。例如，Java虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时，Java虚拟机（JVM）一般会选择线程终止。

这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，如Java虚拟机运行错误（Virtual MachineError）、类定义错误（NoClassDefFoundError）等。这些错误是不可查的，因为它们在应用程序的控制和处理能力之 外，而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说，即使确实发生了错误，本质上也不应该试图去处理它所引起的异常状况。在 Java中，错误通过Error的子类描述。

Exception（异常）:是程序本身可以处理的异常。

Exception 类有一个重要的子类 RuntimeException。RuntimeException 类及其子类表示“JVM 常用操作”引发的错误。例如，若试图使用空值对象引用、除数为零或数组越界，则分别引发运行时异常（NullPointerException、ArithmeticException）和 ArrayIndexOutOfBoundException。

注意：异常和错误的区别：异常能被程序本身可以处理，错误是无法处理。

二、Exception

一般分为Checked异常和Runtime异常，所有RuntimeException类及其子类的实例被称为Runtime异常，不属于该范畴的异常则被称为CheckedException。

①Checked异常

只有java语言提供了Checked异常，Java认为Checked异常都是可以被处理的异常，所以Java程序必须显示处理Checked异常。如果程序没有处理Checked异常，该程序在编译时就会发生错误无法编译。这体现了Java的设计哲学：没有完善错误处理的代码根本没有机会被执行。对Checked异常处理方法有两种

1 当前方法知道如何处理该异常，则用try...catch块来处理该异常。
2 当前方法不知道如何处理，则在定义该方法是声明抛出该异常。

package cn.xy.test; 
   
 import java.io.IOException; 
   
 /** 
 * Checked异常测试方法 
 * @author xy 
 * 
 */ 
 public class CheckedExceptionMethods 
 { 
   // 总异常类，既有checkedException又有RuntimeException，所以其中的checkedException必须处理 
   public void method1() throws Exception 
   { 
     System.out.println("我是抛出异常总类的方法"); 
   } 
   
   // 捕获并处理这个异常 
   public void testMethod1_01() 
   { 
     try 
     { 
       method1(); 
     } 
     catch (Exception e) 
     { 
       e.printStackTrace(); 
     } 
   } 
   
   // 把异常传递下去 
   public void testMethod1_02() throws Exception 
   { 
     method1(); 
   } 
   
   public void testMethod1_03() throws Exception 
   { 
     throw new Exception(); 
   } 
   
   public void testMethod1_04() 
   { 
     try 
     { 
       throw new Exception(); 
     } 
     catch (Exception e) 
     { 
       e.printStackTrace(); 
     } 
   } 
   
   // checkedException典型代表IOException 
   public void method2() throws IOException 
   { 
     System.out.println("我是抛出IO异常的方法"); 
   } 
   
   public void testMethod2_01() 
   { 
     try 
     { 
       method2(); 
     } 
     catch (Exception e) 
     { 
       e.printStackTrace(); 
     } 
   } 
   
   public void testMethod2_02() throws Exception 
   { 
     method2(); 
   } 
   
 }

我们比较熟悉的Checked异常有

Java.lang.ClassNotFoundException
Java.lang.NoSuchMetodException
java.io.IOException

②RuntimeException

Runtime如除数是0和数组下标越界等，其产生频繁，处理麻烦，若显示申明或者捕获将会对程序的可读性和运行效率影响很大。所以由系统自动检测并将它们交给缺省的异常处理程序。当然如果你有处理要求也可以显示捕获它们。

package cn.xy.test; 
  
/** 
 * 运行时异常测试方法 
 * @author xy 
 * 
 */ 
public class RuntimeExcetionMethods 
{ 
  public void method3() throws RuntimeException 
  { 
    System.out.println("我是抛出运行时异常的方法"); 
  } 
  
  public void testMethod3_01() 
  { 
    method3(); 
  } 
  
  public void testMethod1_02() 
  { 
    throw new RuntimeException(); 
  } 
}

我们比较熟悉的RumtimeException类的子类有

Java.lang.ArithmeticException
Java.lang.ArrayStoreExcetpion
Java.lang.ClassCastException
Java.lang.IndexOutOfBoundsException
Java.lang.NullPointerException

三、Error

当程序发生不可控的错误时，通常做法是通知用户并中止程序的执行。与异常不同的是Error及其子类的对象不应被抛出。

Error是throwable的子类，代表编译时间和系统错误，用于指示合理的应用程序不应该试图捕获的严重问题。

Error由Java虚拟机生成并抛出，包括动态链接失败，虚拟机错误等。程序对其不做处理。