public String myMethod() { 
throw new MyError(); 
} 

public String myMethod() { 
throw new MyException(); 
} 

public String myMethod() throws MyException { 
throw new MyException(); 
} 

package java.lang; 
import java.io.*; 
/** 
* 
* Throwable是所有Error和Exceptiong的父類 
* 注意它有四個構(gòu)造函數(shù): 
* 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; 
 
  /** 
  * 表示當(dāng)前異常由那個Throwable引起 
  * 如果為null表示此異常不是由其他Throwable引起的 
  * 如果此對象與自己相同,表明此異常的起因?qū)ο筮€沒有被初始化 
  */ 
  private Throwable cause = this; 
 
  /** 
  * 描述異常軌跡的數(shù)組 
  */ 
  private StackTraceElement[] stackTrace; 
 
  /** 
  * 構(gòu)造函數(shù),起因?qū)ο鬀]有被初始化可以在以后使用initCause進(jìn)行初始化 
  * fillInStackTrace可以用來初始化它的異常軌跡的數(shù)組 
  */ 
  public Throwable() { 
   fillInStackTrace(); 
  } 
 
  /** 
  * 構(gòu)造函數(shù) 
  */ 
  public Throwable(String message) { 
   //填充異常軌跡數(shù)組 
   fillInStackTrace(); 
   //初始化異常描述信息 
   detailMessage = message; 
  } 
 
  /** 
  * 構(gòu)造函數(shù),cause表示起因?qū)ο?
  */ 
  public Throwable(String message, Throwable cause) { 
   fillInStackTrace(); 
   detailMessage = message; 
   this.cause = cause; 
  } 
 
  /** 
  * 構(gòu)造函數(shù) 
  */ 
  public Throwable(Throwable cause) { 
   fillInStackTrace(); 
   detailMessage = (cause==null ? null : cause.toString()); 
   this.cause = cause; 
  } 
 
  /** 
  * 獲取詳細(xì)信息 
  */ 
  public String getMessage() { 
   return detailMessage; 
  } 
 
  /** 
  * 獲取詳細(xì)信息 
  */ 
  public String getLocalizedMessage() { 
   return getMessage(); 
  } 
 
  /** 
  * 獲取起因?qū)ο?
  */ 
  public Throwable getCause() { 
   return (cause==this ? null : cause); 
  } 
 
  /** 
  * 初始化起因?qū)ο?這個方法只能在未被初始化的情況下調(diào)用一次 
  */ 
  public synchronized Throwable initCause(Throwable cause) { 
   //如果不是未初始化狀態(tài)則拋出異常 
   if (this.cause != this) 
    throw new IllegalStateException("Can't overwrite cause"); 
   
   //要設(shè)置的起因?qū)ο笈c自身相等則拋出異常 
   if (cause == this) 
    throw new IllegalArgumentException("Self-causation not permitted"); 
   
   //設(shè)置起因?qū)ο?
   this.cause = cause; 
   //返回設(shè)置的起因的對象 
   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) { 
   //調(diào)用當(dāng)前對象的toString方法 
    s.println(this); 
   //獲取異常軌跡數(shù)組 
    StackTraceElement[] trace = getOurStackTrace(); 
    
   //打印出每個元素的字符串表示 
    for (int i=0; i < trace.length; i++) 
    s.println("\tat " + trace[i]); 
 
   //獲取起因?qū)ο?
    Throwable ourCause = getCause(); 
    
   //遞歸的打印出起因?qū)ο蟮男畔?
    if (ourCause != null) 
    ourCause.printStackTraceAsCause(s, trace); 
   } 
  } 
 
  /** 
  * 打印起因?qū)ο蟮男畔?
  * @param s 打印的流 
  * @param causedTrace 有此對象引起的異常的異常軌跡 
  */ 
  private void printStackTraceAsCause(PrintStream s, 
           StackTraceElement[] causedTrace) 
  { 
   //獲得當(dāng)前的異常軌跡 
   StackTraceElement[] trace = getOurStackTrace(); 
   //m為當(dāng)前異常軌跡數(shù)組的最后一個元素位置, 
   //n為當(dāng)前對象引起的異常的異常軌跡數(shù)組的最后一個元素 
   int m = trace.length-1, n = causedTrace.length-1; 
   //分別從兩個數(shù)組的后面做循環(huán),如果相等則一直循環(huán),直到不等或數(shù)組到頭 
   while (m >= 0 && n >=0 && trace[m].equals(causedTrace[n])) { 
    m--; n--; 
   } 
   
   //相同的個數(shù) 
   int framesInCommon = trace.length - 1 - m; 
   
   //打印出不同的錯誤軌跡 
   s.println("Caused by: " + this); 
   for (int i=0; i <= m; i++) 
    s.println("\tat " + trace[i]); 
   //如果有相同的則打印出相同的個數(shù) 
   if (framesInCommon != 0) 
    s.println("\t... " + framesInCommon + " more"); 
 
   //獲得此對象的起因?qū)ο?并遞歸打印出信息 
   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); 
   } 
  } 
 
  /** 
  * 打印起因?qū)ο蟮男畔?
  */ 
  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(); 
 
  /** 
  * 返回當(dāng)前的異常軌跡的拷貝 
  */ 
  public StackTraceElement[] getStackTrace() { 
   return (StackTraceElement[]) getOurStackTrace().clone(); 
  } 
 
  
  /** 
  * 獲取當(dāng)前的異常軌跡 
  */ 
  private synchronized StackTraceElement[] getOurStackTrace() { 
   //如果第一次調(diào)用此方法則初始化異常軌跡數(shù)組 
   if (stackTrace == null) { 
   //獲得異常軌跡深度 
    int depth = getStackTraceDepth(); 
   //創(chuàng)建新的異常軌跡數(shù)組,并填充它 
    stackTrace = new StackTraceElement[depth]; 
    
   for (int i=0; i < depth; i++) 
    stackTrace[i] = getStackTraceElement(i);//獲取指定位標(biāo)的異常軌跡 
   } 
   
   return stackTrace; 
  } 
 
  /** 
  * 設(shè)置異常軌跡 
  */ 
  public void setStackTrace(StackTraceElement[] stackTrace) { 
   //拷貝設(shè)置參數(shù) 
   StackTraceElement[] defensiveCopy = 
    (StackTraceElement[]) stackTrace.clone(); 
   
   //如果設(shè)置參數(shù)有空元素則拋出異常 
   for (int i = 0; i < defensiveCopy.length; i++) 
    if (defensiveCopy[i] == null) 
     throw new NullPointerException("stackTrace[" + i + "]"); 
 
   //設(shè)置當(dāng)前對象的異常軌跡 
   this.stackTrace = defensiveCopy; 
  } 
 
  /** 
  * 異常軌跡的深度,0表示無法獲得 
  */ 
  private native int getStackTraceDepth(); 
 
  /** 
  * 獲取指定位標(biāo)的異常軌跡 
  */ 
  private native StackTraceElement getStackTraceElement(int index); 
 
  
  private synchronized void writeObject(java.io.ObjectOutputStream s) 
   throws IOException 
  { 
   getOurStackTrace(); 
   s.defaultWriteObject(); 
  } 
}