<var id="fnfpo"><source id="fnfpo"></source></var>

<rp id="fnfpo"></rp>

<em id="fnfpo"><object id="fnfpo"><input id="fnfpo"></input></object></em><em id="fnfpo"><acronym id="fnfpo"></acronym></em>

<th id="fnfpo"><track id="fnfpo"></track></th>

<progress id="fnfpo"><track id="fnfpo"></track></progress>

<tbody id="fnfpo"><pre id="fnfpo"></pre></tbody>

x

x

Java語言基礎：異常機制

發布時間：2011-3-29 19:38 發布者：1770309616

關鍵詞： Java語言基礎 , 異常機制

Java語言基礎.pdf (205.39 KB)

1.  拋出異常•通過throw new ThrowableClass語法可以拋出一個異常，其中ThrowableClass是一個從Throwable繼承的類，或者是Throwable類本身，先看下面的
view plaincopy to clipboardprint?
01.public void proc(){
02. // Exception是Throwable的繼承類，代表最基本的異常
03. throw new Exception("hello");
04.}
public void proc(){
// Exception是Throwable的繼承類，代表最基本的異常
throw new Exception("hello");
}
•上面的代碼會導致編譯錯誤，對于有拋出異常的方法，編譯器強制要求：要么在方法上聲明要拋出的異常(稱為異常說明)，要么在方法中用try塊捕獲這個異常。
view plaincopy to clipboardprint?
01.// 用異常說明，說明該方法要拋出的異常
02.public void proc() throws Exception{
03. throw new Exception("hello");
04.}
05.
06.// 用try塊捕獲該異常
07.public void proc(){
08. try {
09.       throw new Exception("hello");
10. } catch (Exception e) {
11.       e.printStackTrace();
12. }
13.}
// 用異常說明，說明該方法要拋出的異常
public void proc() throws Exception{
throw new Exception("hello");
}

// 用try塊捕獲該異常
public void proc(){
try {
      throw new Exception("hello");
} catch (Exception e) {
      e.printStackTrace();
}
} 異常說明可以是方法拋出的異常類本身，也可以是異常類的基類，比如throws后面可以是throwable。•上面說到對于有拋出異常的方法，必須帶有方法聲明，這并不準確，當拋出的異常類是RuntimeException或其繼承類時，不需要異常說明：
view plaincopy to clipboardprint?
01.// RuntimeException或其繼承類不需要異常聲明
02.public void proc(){
03. throw new RuntimeException("hello");
04.}
// RuntimeException或其繼承類不需要異常聲明
public void proc(){
throw new RuntimeException("hello");
} •一個方法即使內部沒有拋出異常，也仍然可以帶有異常說明：
view plaincopy to clipboardprint?
01.public void proc2() throws NullPointerException, FileNotFoundException {
02.}
public void proc2() throws NullPointerException, FileNotFoundException {
} •一個方法若帶有異常說明，則調用它的其他方法也要帶有異常說明，或者要捕獲可能拋出的異常：
view plaincopy to clipboardprint?
01.class A {
02. public void proc() throws Exception {
03.       throw new Exception("hello");
04. }
05. // 異常聲明
06. public void proc1() throws Exception {
07.       proc();
08. }
09. // 異常聲明，聲明中的類可以是基類
10. public void proc2() throws Throwable {
11.       proc();
12. }
13. // 直接捕獲異常
14. public void proc3() {
15.       try {
16.          proc();
17.       } catch (Exception e) {
18.          e.printStackTrace();
19.       }
20. }
21.}
class A {
public void proc() throws Exception {
      throw new Exception("hello");
}
// 異常聲明
public void proc1() throws Exception {
      proc();
}
// 異常聲明，聲明中的類可以是基類
public void proc2() throws Throwable {
      proc();
}
// 直接捕獲異常
public void proc3() {
      try {
         proc();
      } catch (Exception e) {
         e.printStackTrace();
      }
}
} •可以基于Exception現實自己的異常類：
view plaincopy to clipboardprint?
01.class MyException1 extends Exception {
02.}
03.class MyException2 extends Exception {
04.}
05.class A {
06. public void proc() throws MyException1, MyException2{
07. }
08.}
class MyException1 extends Exception {
}
class MyException2 extends Exception {
}
class A {
public void proc() throws MyException1, MyException2{
}
}
2.  捕獲異常和結束清理•用try{}塊包圍住可能引發異常的代碼，后面緊跟著異常處理器(即catch(...){}塊)；catch塊可以有多個，()中聲明要捕獲的異常類。當try塊拋出一個異常時，執行代碼將跳到catch塊去，并從第一個catch塊開始匹配，直到找到符合的catch塊。請看下面的代碼說明：
view plaincopy to clipboardprint?
01.class MyException1 extends Exception {
02.}
03.class MyException2 extends Exception {
04.}
05.class MyException3 extends Exception {
06.}
07.class A {
08. public void proc() throws Exception{
09.       try{
10.          // 僅僅為了演示用
11.          Random random = new Random();
12.          int i = random.nextInt(3);
13.          if (i == 0)
14.             throw new MyException1();
15.          else if (i == 1)
16.             throw new MyException2();
17.          else if (i == 2)
18.             throw new MyException3();
19.       }
20.       catch(MyException1 e){
21.          // 當拋出MyException1時會跳到這里來。
22.          e.printStackTrace();
23.       }
24.       catch(MyException2 e){
25.          // 當拋出MyException2時會跳到這里來。
26.          e.printStackTrace();
27.       }
28.       catch (Exception e) {
29.          // 當拋出MyException3時，由于上面沒有匹配的處理器，
30.          // 并且Exception是MyException3的基類，所以會跳到這里來。
31.          e.printStackTrace();
32.          // 可以重新拋出異常，系統將尋找更外層的異常處理器
33.          throw e;
34.       }
35. }
36.}
37.
38.public class Main {
39. public static void main(String[] args) {
40.       A a = new A();
41.       try {
42.          a.proc();
43.       } catch (Exception e) {
44.          e.printStackTrace();
45.       }
46. }
47.}
class MyException1 extends Exception {
}
class MyException2 extends Exception {
}
class MyException3 extends Exception {
}
class A {
public void proc() throws Exception{
      try{
         // 僅僅為了演示用
         Random random = new Random();
         int i = random.nextInt(3);
         if (i == 0)
            throw new MyException1();
         else if (i == 1)
            throw new MyException2();
         else if (i == 2)
            throw new MyException3();
      }
      catch(MyException1 e){
         // 當拋出MyException1時會跳到這里來。
         e.printStackTrace();
      }
      catch(MyException2 e){
         // 當拋出MyException2時會跳到這里來。
         e.printStackTrace();
      }
      catch (Exception e) {
         // 當拋出MyException3時，由于上面沒有匹配的處理器，
         // 并且Exception是MyException3的基類，所以會跳到這里來。
         e.printStackTrace();
         // 可以重新拋出異常，系統將尋找更外層的異常處理器
         throw e;
      }
}
}

public class Main {
public static void main(String[] args) {
      A a = new A();
      try {
         a.proc();
      } catch (Exception e) {
         e.printStackTrace();
      }
}
} •在異常處理器后面加上finally子句，無論異常是否發生，finally子句一定會被調用到，finally子句常被用于清理垃圾回收之外的資源，比如打開的文件，網絡鏈接等：
view plaincopy to clipboardprint?
01.class MyException1 extends Exception {
02.}
03.
04.class A {
05. public void proc(){
06.       try{
07.          throw new MyException1();
08.       }
09.       catch(MyException1 e){
10.          e.printStackTrace();
11.       }
12.       finally {
13.          System.out.println("Hello");
14.       }
15. }
16.}
17.
18.public class Main {
19. public static void main(String[] args) {
20.       A a = new A();
21.       a.proc();
22. }
23.}
24.最后的輸出是：
25.MyException1
26. at A.proc(Main.java:12)
27. at Main.main(Main.java:27)
28.Hello
class MyException1 extends Exception {
}

class A {
public void proc(){
      try{
         throw new MyException1();
      }
      catch(MyException1 e){
         e.printStackTrace();
      }
      finally {
         System.out.println("Hello");
      }
}
}

public class Main {
public static void main(String[] args) {
      A a = new A();
      a.proc();
}
}
最后的輸出是：
MyException1
at A.proc(Main.java:12)
at Main.main(Main.java:27)
Hello
3.  異常的限制：對于繼承類，它如果所覆蓋的方法有異常說明，則所列出的異常類，必須是基類該方法所列出的異常類的子集，先看一個例子：view plaincopy to clipboardprint?
01.class MyException1 extends Exception {
02.}
03.class A {
04. public void proc(){
05. }
06.}
07.class B extends A {
08. // 編譯錯誤：因為A.proc沒有異常說明，所以子類也不能有異常說明
09. // 解決的方法是為A.proc加上異常說明：throws MyException1
10. // 或者在throw new MyException1();加上try塊并去掉異常說明
11. public void proc() throws MyException1 {
12.       throw new MyException1();
13. }
14.}
class MyException1 extends Exception {
}
class A {
public void proc(){
}
}
class B extends A {
// 編譯錯誤：因為A.proc沒有異常說明，所以子類也不能有異常說明
// 解決的方法是為A.proc加上異常說明：throws MyException1
// 或者在throw new MyException1();加上try塊并去掉異常說明
public void proc() throws MyException1 {
      throw new MyException1();
}
}
再看一下例子：view plaincopy to clipboardprint?
01.class MyException1 extends Exception {
02.}
03.class MyException2 extends Exception {
04.}
05.class A {
06. public void proc() throws MyException1 {
07. }
08.}
09.class B extends A {
10. // 錯誤：因為A.proc只聲明了MyException1異常
11. public void proc() throws MyException2 {
12. }
13.}
class MyException1 extends Exception {
}
class MyException2 extends Exception {
}
class A {
public void proc() throws MyException1 {
}
}
class B extends A {
// 錯誤：因為A.proc只聲明了MyException1異常
public void proc() throws MyException2 {
}
} 構造器是一個例外，繼承類可以聲明更多的異常類，但必須加上基類所聲明的異常類：view plaincopy to clipboardprint?
01.class MyException1 extends Exception {
02.}
03.class MyException2 extends Exception {
04.}
05.class A {
06. A() throws MyException1 {
07.
08. }
09. public void proc() throws MyException1 {
10. }
11.}
12.class B extends A {
13. B() throws MyException1, MyException2 {
14. }
15.}
class MyException1 extends Exception {
}
class MyException2 extends Exception {
}
class A {
A() throws MyException1 {

}
public void proc() throws MyException1 {
}
}
class B extends A {
B() throws MyException1, MyException2 {
}
}

本文地址：http://www.portaltwn.com/thread-60387-1-1.html 【打印本頁】

本站部分文章為轉載或網友發布，目的在于傳遞和分享信息，并不代表本網贊同其觀點和對其真實性負責；文章版權歸原作者及原出處所有，如涉及作品內容、版權和其它問題，我們將根據著作權人的要求，第一時間更正或刪除。

相關文章

網友評論

貿澤電子有獎問答視頻，答對領10元微信紅包

廠商推薦

關于我們 - 服務條款 - 使用指南 - 站點地圖 - 友情鏈接 - 聯系我們
電子工程網 © 版權所有京ICP備16069177號 | 京公網安備11010502021702

快速回復 返回頂部 返回列表

精品一区二区三区自拍图片区_国产成人亚洲精品_亚洲Va欧美va国产综合888_久久亚洲国产精品五月天婷