关于自定义异常中为什么带参构造器需要显示调用父类异常的带参构造器详解编程语言

在听课的时候听到自定义异常时，视频上讲的定义异常的时候如果是带参构造器需要显示调用父类异常的带参构造器，原因是什么呢？

首先我们需要看一下Exception和ERROR的父类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定义了一个私有属性detailMessage来存储异常信息，虽然是私有属性，但是在子类的内存中也是会存在的，而且从父类继承的toString、getmessage等方法也需要用到这个私有属性，如何对子类对象中的父类属性进行初始化？那就只能调用父类的构造器了。如下：

public class MyException extends Exception { 
 
 
public MyException(String message) { 
super(message); 
} 
}

这样才能使得继承的toString等到方法打印出你自己的错误信息。