《Thinking in Java》上對這章的講解不少，可見重要性，學(xué)習(xí)和總結(jié)一些主要的記錄下來。

一、創(chuàng)建自定義異常

package Exception; 
 class SimpleException extends Exception{}
 
 public class InheritingException{
  
  public void f() throws SimpleException {
   System.out.println("Throw SimpleException from f()");
   throw new SimpleException();
  }
  
  public static void main(String[] args) {
   InheritingException sed = new InheritingException();
   try {
    sed.f();
   } catch (SimpleException e) {
    e.printStackTrace();
   }
  }
  
 }

輸出：

Throw SimpleException from f()
Exception.SimpleException
at Exception.InheritingException.f(InheritingException.java:10)
at Exception.InheritingException.main(InheritingException.java:19)

　　throw與throws的區(qū)別與詳情

　　編譯器創(chuàng)建了默認(rèn)構(gòu)造器，它將自動調(diào)用基類的默認(rèn)構(gòu)造器。

　　對異常來說，最重要的部分就是類名，其它也沒用，可以增加一個帶參的構(gòu)造方法。

　　比如NullPointerException：

 public class NullPointerException extends RuntimeException {
  private static final long serialVersionUID = 5162710183389028792L;
 
  /**
  * Constructs a {@code NullPointerException} with no detail message.
  */
  public NullPointerException() {
   super();
 }

  /**
  * Constructs a {@code NullPointerException} with the specified
   * detail message.
  *
  * @param s the detail message.
  */
  public NullPointerException(String s) {
   super(s);
  }
 }

二、捕獲異常

　　1）try塊

　　　　如果在方法內(nèi)部拋出了異常（或者在方法內(nèi)部調(diào)用的其他方法拋出了異常），這個方法將在拋出異常的過程中結(jié)束。

　　　　要是不希望方法就此結(jié)束，可以在方法內(nèi)設(shè)置一個特殊的塊來捕獲異常。

try{
 //exceptions 
}

 　　2）異常處理程序

　　　　異常處理程序緊跟在try塊之后，以關(guān)鍵字catch表示：

try{
 //exceptions 
} catch(Type1 id1) {
 //Type1 
} catch(Type2 id2) {
 //Type2
}

　　　　當(dāng)異常被拋出時，異常處理機制將負(fù)責(zé)搜尋參數(shù)與異常類型相匹配的第一個處理程序。然后進入catch子句執(zhí)行，此時認(rèn)為異常得到了處理。

　　　　注意，只有匹配的catch子句才能得到執(zhí)行，這與switch語句不同。

 　　3）棧軌跡

　　　　printStackTrace()方法所提供的信息可以通過getStackTrace()方法來直接訪問，這個方法將返回一個由棧軌跡中的元素所構(gòu)成的數(shù)組，其中每一個元素都表示

　　棧中的一幀。元素0是棧頂元素，并且是調(diào)用序列中的最后一個方法調(diào)用。數(shù)組中最后一個元素和棧底是調(diào)用序列中的第一個方法調(diào)用。

 public class WhoCalled {
  static void f() {
   try {
    throw new Exception();
   } catch (Exception e) {
    for(StackTraceElement ste : e.getStackTrace()) {
     System.out.println("line: " + ste.getLineNumber() + " method: " + ste.getMethodName());
    }
   }
  }
  static void g() {f();}
  static void h() {g();}
  public static void main(String[] args) {f();g();h();}
 }

　　程序輸出：

line: 5 method: f
line: 14 method: main
line: 5 method: f
line: 12 method: g
line: 14 method: main
line: 5 method: f
line: 12 method: g
line: 13 method: h
line: 14 method: main

三、Java標(biāo)準(zhǔn)異常

　　Throwable這個Java類被用來表示任何可以作為異常被拋出的類。

　　Throwable對象可分為兩種類型：

1  Error用來表示編譯時和系統(tǒng)錯誤。

2  Exception是可以被拋出的基本類型，程序員關(guān)心的基類型通常是Exception。

四、RuntimeException

if(t == null) {
 throw new NullPointerException(); 
}

　　如果對Null引用進行調(diào)用，Java會自動拋出NullPointerException異常，所以上述代碼是多余的，它屬于Java的標(biāo)準(zhǔn)運行時檢測的一部分：

public class NeverCaught {
  static void f() {
   throw new RuntimeException();
  }
  static void g() {f();}
  public static void main(String[] args) {
   g();
  }
 }

輸出：

Exception in thread "main" java.lang.RuntimeException

at Exception.NeverCaught.f(NeverCaught.java:6)

at Exception.NeverCaught.g(NeverCaught.java:10)

at Exception.NeverCaught.main(NeverCaught.java:14)

　　從輸出可以發(fā)現(xiàn)，RuntimeException是一個特例，對于這種異常類型，編譯器不需要異常說明，其輸出被報告給了System.err。

　　如果RuntimeException沒有被捕獲而直達main()，那么在程序退出前將調(diào)用異常的printStackTrace()方法。

　　*注意：

　　　　只能在代碼中忽略RuntimeException（及其子類）類型的異常，其它異常類型的處理都是由編譯器強制實施的。

　　1）常見的五種RuntimeException

NullPointerException - 空指針引用異常

ClassCastException - 類型強制轉(zhuǎn)換異常

IllegalArgumentException - 傳遞非法參數(shù)異常

ArithmeticException - 算術(shù)運算異常

ArrayStoreException - 向數(shù)組中存放與聲明類型不兼容對象異常

IndexOutOfBoundsException - 下標(biāo)越界異常

NegativeArraySizeException - 創(chuàng)建一個大小為負(fù)數(shù)的數(shù)組錯誤異常

NumberFormatException - 數(shù)字格式異常

SecurityException - 安全異常

UnsupportedOperationException - 不支持的操作異常

五、使用finally進行清理

 class ThreeException extends Exception {}
 public class FinallyWorks {
  static int count = 0;
  public static void main(String[] args) {
   while(true) {
    try {
     if(count++ == 0) {
      throw new ThreeException();
     }
     System.out.println("No exception");
    } catch (ThreeException e) {
     System.out.println("ThreeException");
    } finally {
     System.out.println("In finally clause");
     if(count == 2) 
      break;
    }
   }
  }
 }

　　這個程序給了我們一些思路（確實。。），如果把try塊放在循環(huán)里，就建立了一個“程序繼續(xù)執(zhí)行之前必須要到達”的條件。

　　還可以加入一個static類型的計數(shù)器或者別的裝置，使循環(huán)在放棄之前能夠嘗試一定的次數(shù)。這將使程序的健壯性更上一個臺階（好叼的樣子）。

　　1）finally用來做什么

　　　　當(dāng)要把除內(nèi)存之外的資源恢復(fù)到它們的初始狀態(tài)時，就要用到finally子句。

　　2）在return中使用finally

　　　　因為finally子句總是會執(zhí)行的，所以在一個方法中，可以從多個點返回，并且可以保證重要的清理工作仍舊會執(zhí)行：

class ThreeException extends Exception {}
 public class FinallyWorks {
  static int count = 0;
  public static void main(String[] args) {
   while(true) {
    try {
     if(count++ == 0) {
      throw new ThreeException();
     }
     System.out.println("No exception");
     return;
    } catch (ThreeException e) {
     System.out.println("ThreeException");
    } finally {
     System.out.println("In finally clause");
     if(count == 3) 
      break;
    }
   }
  }
 }

第一次循環(huán)，首先執(zhí)行第7行，符合條件，拋出異常，執(zhí)行catch塊，最后執(zhí)行finally清理，不符合第16行判斷，繼續(xù)循環(huán)

第二次循環(huán)，不符合第7行判斷，拋出異常，并return，但依舊執(zhí)行finally清理，不符合第16行判斷，但try塊中已經(jīng)執(zhí)行return，所以程序結(jié)束，輸出：

ThreeException
In finally clause
No exception
In finally clause

　　3）Java異常的缺憾：異常丟失

 public class ExceptionSilencer {
  public static void main(String[] args) {
  try {
    throw new RuntimeException();
   } finally {
    return;
   }
  }
 }

以上就是JAVA基礎(chǔ)--如何通過異常處理錯誤的詳細(xì)內(nèi)容，更多關(guān)于JAVA 通過異常處理錯誤的資料請關(guān)注腳本之家其它相關(guān)文章！

最新評論