JDK 源码：Throwable

Throwable 是 Java 异常体系的根类，它定义了 Java 中所有错误和异常的基本结构。以下是 JDK 8 中 Throwable 类的部分源代码：

public class Throwable implements Serializable {
    private transient Object backtrace;
    private String detailMessage;
    private static final long serialVersionUID = -3042686055658047285L;
    private Throwable cause = this;

    public Throwable() {
        fillInStackTrace();
    }

    public Throwable(String message) {
        fillInStackTrace();
        detailMessage = message;
    }

    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;
    }

    protected Throwable(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        if (writableStackTrace) {
            fillInStackTrace();
        } else {
            this.backtrace = null;
        }
        detailMessage = message;
        this.cause = cause;
        if (!enableSuppression && cause != null) {
            fillInStackTrace();
        }
    }

    public String getMessage() {
        return detailMessage;
    }

    public String getLocalizedMessage() {
        return getMessage();
    }

    public synchronized 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) {
        printStackTrace(new PrintWriter(s));
    }

    public void printStackTrace(PrintWriter s) {
        synchronized (s) {
            s.println(this);
            StackTraceElement[] trace = getStackTrace();
            for (StackTraceElement traceElement : trace) {
                s.println("\tat " + traceElement);
            }
            Throwable ourCause = getCause();
            if (ourCause != null) {
                ourCause.printStackTraceAsCause(s, trace);
            }
        }
    }

    private void printStackTraceAsCause(PrintWriter s, StackTraceElement[] causedTrace) {
        StackTraceElement[] trace = getStackTrace();
        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 synchronized Throwable fillInStackTrace() {
        if (backtrace != null || backtrace != null) {
            fillInStackTrace(0);
            backtrace = null;
        }
        return this;
    }

    private native Throwable fillInStackTrace(int dummy);

    public StackTraceElement[] getStackTrace() {
        return getOurStackTrace().clone();
    }

    private synchronized StackTraceElement[] getOurStackTrace() {
        if (backtrace == null || backtrace == null) {
            return new StackTraceElement[0];
        } else {
            return (StackTraceElement[]) backtrace;
        }
    }

    public void setStackTrace(StackTraceElement[] stackTrace) {
        StackTraceElement[] defensiveCopy = stackTrace.clone();
        if (defensiveCopy.length == 0) {
            throw new IllegalArgumentException("Given stack trace is empty");
        }
        this.backtrace = defensiveCopy;
    }
}

Throwable 类定义了一些基本的异常处理方法，如获取异常消息、获取异常原因、获取异常堆栈信息等。它还提供了 fillInStackTrace 方法，用于生成当前线程的堆栈跟踪信息。