`
Riddick
  • 浏览: 640151 次
  • 性别: Icon_minigender_1
  • 来自: 武汉
社区版块
存档分类
最新评论

Java.lang.throwable源代码

    博客分类:
  • J2SE
阅读更多
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();
      }
}
分享到:
评论

相关推荐

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

    在Java编程语言中,`java.lang.Throwable`是所有错误(Error)和异常(Exception)的顶级父类,它是Java异常处理机制的核心组成部分。这个类位于`java.lang`包中,是Java标准库的一部分,提供了处理运行时问题的标准...

    java-jdk源代码免费分享 src.zip

    1. **类库解析**:JDK源代码中包含了Java标准类库的所有源文件,如`java.lang`、`java.util`、`java.io`等包。这些类库提供了基础的数据类型、集合框架、输入/输出操作等核心功能。 2. **垃圾收集器(Garbage ...

    Java SDK源代码

    Java SDK源代码是Java开发工具包的原始代码,包含了Java平台标准版(Java SE)的核心类库和其他组件的实现细节。这些源代码对于Java开发者来说是极其宝贵的资源,因为它们揭示了Java API背后的工作原理,有助于理解...

    常见的java异常.pdf

    在Java中,异常被组织成一个层次结构,根类是`java.lang.Throwable`,其下有两个主要子类:`Error`和`Exception`。`Error`通常表示系统级的错误,比如内存溢出或虚拟机错误,而`Exception`是程序中可以预见和处理的...

    java各个类的源代码

    这个压缩包包含了Java核心库的部分源代码,对于深入理解Java的工作原理和学习编程技术非常有帮助。以下将详细解释Java类库中的关键概念和组件。 1. **Java基础类**:在`java`目录下,你会找到Java基础类库,包括`...

    Java rt.jar 源码分析

    Java的rt.jar是Java运行时环境(JRE)的核心库之一,它包含了Java标准类库的源代码。这个库中的类支持Java程序的基础运行,包括集合、I/O、网络编程、多线程、反射等核心功能。源码分析是提升Java开发者技能的重要...

    java11英文api文档,jdk-11.0.5_doc-all.zip

    9. **异常处理**:Java的异常处理机制通过`java.lang.Throwable`、`java.lang.Exception`和`java.lang.RuntimeException`类体现,API文档详细解释了如何抛出、捕获和处理异常。 10. **反射和注解**:`java.lang....

    jdk1.8 rt.jar 源码

    `rt_source_jdk1.8` 这个压缩包文件就是 JDK 1.8 版本中 `rt.jar` 的源代码,你可以通过解压并导入到IDE(如Eclipse或IntelliJ IDEA)来查看和学习。这将使你能够跟踪类的方法实现,理解内部工作机制,以及学习如何...

    Java常用类库

    6. **异常处理**:`java.lang.Throwable`及其子类定义了Java中的异常,异常处理机制通过try-catch-finally语句块实现,有助于编写健壮的代码。 7. **日期和时间API**:Java 8引入了新的日期和时间API (`java.time`...

    JDK7-API-帮助文档(英文版).rar

    9. **编译器API**:`com.sun.tools.javac`提供了编译Java源代码的能力,使得在程序中动态编译Java代码成为可能。 10. **Nashorn JavaScript引擎**:JDK 7引入了Nashorn JavaScript引擎,允许在Java应用中直接执行...

    java源码之jdk源码

    以下将详细探讨Java源代码和JDK源码中的关键知识点。 1. **类加载器(ClassLoader)**: - 类加载器负责查找和加载Java类到JVM中。在`java.lang.ClassLoader`中,我们能看到如何通过路径查找.class文件,以及双亲...

    rtjar_rt.jar_shsh_

    在开发过程中,`javac`编译器会依赖rt.jar来解析和验证源代码中的类引用。而在运行时,JVM(Java虚拟机)会加载rt.jar,使应用程序能够访问到Java标准库的所有功能。 `shsh`可能是指某种特定的标识或者操作,但在...

    Java 实例 - 异常处理方法源代码-详细教程.zip

    在这个“Java实例 - 异常处理方法源代码-详细教程”中,你将深入学习Java的异常处理机制,并通过实际的源代码示例加深理解。 首先,Java的异常处理基于“try-catch-finally”结构。当可能出现异常的代码块被包裹在`...

    《Java基础入门》_源代码.zip

    《Java基础入门》_源代码.zip是一个包含Java编程初学者入门教程的源代码集合。这个压缩包很可能是为了辅助学习者理解并实践Java语言的基本概念和技术。以下将详细阐述Java基础的一些关键知识点。 1. **Java简介**:...

    java api 官方文档中文版

    `java.lang.annotation`包定义了注解,这是一种元数据,可用来添加额外信息到源代码中。 8. **XML处理**:`javax.xml`包提供了处理XML的工具,如解析、序列化、转换等。 9. **GUI编程**:`java.awt`和`javax.swing...

    java中文API帮助

    4. **异常处理**:Java中的异常处理是通过try-catch-finally语句块实现的,异常类通常继承自`java.lang.Throwable`。通过捕获和处理异常,程序可以更健壮地处理错误和异常情况。 5. **I/O流**:Java的I/O流系统是...

    jdk1.6.0_05源码打包

    开发者可以在这个目录下找到如"java.lang"、"java.util"、"java.io"等核心包的源代码,以及其他如编译器(javac)、JVM相关工具的源码。 **详细知识点** 1. **Java源代码结构**:源代码通常按照包(package)来...

    Java SE 源码 Java SE 源码

    在这个压缩包中,你可能找到了Java SE的原始源代码,这将允许你深入探究这个强大的编程语言的内部机制。 1. **类库解析**:Java SE源码涵盖了核心类库,如`java.lang`、`java.util`、`java.io`等。这些类库提供了...

    [Java参考文档].JDK_API中文版

    10. **注解(Annotation)**:注解是一种元数据,可以在源代码中声明,以提供编译器或运行时系统使用的附加信息。例如,`@Override`确保方法覆盖父类方法,`@Deprecated`标记过时的API。 11. **并发工具**:`java....

Global site tag (gtag.js) - Google Analytics