解析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.
* 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 : String());
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() {
);
}
/**
* 打印出错误轨迹
*/
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();
java的tostring方法//递归的打印出起因对象的信息
if (ourCause != null)
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();
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;
}
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。
发表评论