Java基礎學習總結（22）——異常處理

1、異常的概念

　　異常指的是運行期出現的錯誤，也就是當程序開始執行之後執行期出現的錯誤。出現錯誤時觀察錯誤的名字和行號最爲重要。

　　

 1 package cn.javastudy.summary;  2 
 3 public class TestEx{  4     
 5     public static void main(String args[]){  6         int arr[]={1,2,3};  7         System.out.println(arr[2]);  8         /**
 9  * 這裏使用try……catch來捕獲除以0產生的異常，其基本格式是： 10  * try{ 11  statements;//可能產生異常的語句 12  …… 13  } 14  catch(Throwable-subclass e){//異常參數e 15  statements;//異常處理程序 16  …… 17  } 18          */
19         try{ 20             System.out.println(arr[2]/0); 21         }catch(ArithmeticException ae){//這裏是這個異常參數的類型聲明，即聲明這個異常是屬於哪一種類型的異常
22             System.out.println("系統正在維護中，請稍後！"); 23             /**
24  * 這裏使用printStackTrace()方法把這個錯誤的堆棧信息打印出來。 25  * 所謂的「錯誤堆棧信息」指的是這個錯誤有多是上一個錯誤引發的， 26  * 而上一個錯誤又有多是由另一個錯誤引發的。究竟是由哪一個錯誤引發的， 27  * 把全部的錯誤信息全都打印出來就知道了。這種信息每每能給咱們程序員調試錯誤的提示。 28  * 這些信息頗有用，所以咱們每每使用這個方法把錯誤信息打印出來。 29  * 默認打印錯誤提示信息採用的也是使用這種方法打印出來的 30              */
31  ae.printStackTrace(); 32  } 33  } 34 }

代碼運行結果：

　　

小結：

　　異常是運行期間出現的錯誤，運行期間出現錯誤之後JAVA處理這種錯誤的方式是首先會找相應的catch代碼，看看有沒有使用catch去捕獲異常，若是有catch存在，那麼JAVA就會自動跳到catch那裏去處理異常，若是沒有catch，那麼JAVA將會把這個錯誤拋出去，而後將相關的錯誤信息打印出來。想用catch捕獲異常時必需要寫try，沒有try就不能用catch，try裏面寫的是有可能產生異常的語句，catch裏面寫的是當try裏面的語句運行時出現了異常的處理方式。

　　方法聲明的時候能夠指明這個方法有可能會拋出的異常類型，使用throw拋出異常，聲明方法後面有throws聲明的可能出現的異常必定要去捕獲。

　　

2、異常的分類

　　

3、異常的捕獲和處理

　　Java異常處理的五個關鍵字：try、catch、finally、throw、throws

　　

　　

　　

　　

　　當捕獲到異常之後必定要作出處理，哪怕是把這個異常的錯誤信息打印出來，這是一種良好的編程習慣。若是不處理，那就是把這個錯誤悄悄地隱藏起來了，但是這個錯誤依然是存在的，只不過看不到了而已。這是一種很是危險的編程習慣，絕對不能這樣作，捕獲到異常就必定要作出處理，實在處理不了就把異常拋出去，讓別的方法去處理。總之就是不能捕獲到異常以後卻又不作出相應的處理，這是一種很是很差的編程習慣。

　　任何方法往外拋能處理的異常的時候都有一種簡單的寫法：「throws Exception」，由於Exception類是全部能處理的異常類的根基類，所以拋出Exception類就會拋出全部可以被處理的異常類裏了。使用「throws Exception」拋出全部能被處理的異常以後，這些被拋出來的異常就是交給JAVA運行時系統處理了，而處理的方法是把這些異常的相關錯誤堆棧信息所有打印出來。除了在作測試之外，在實際當中編程的時候，在main方法裏拋Exception是一個很是很差的編程習慣，應該使用try……catch去捕獲異常並處理掉捕獲後的異常。不能直接在main方法裏把Exception拋出去交給JAVA運行時系統出力就完事了，這是一種不負責任的表現。若是想把程序寫得特別健壯，使用try……catch去捕獲異常並處理掉捕獲後的異常是必不可少的作法。

4、try...cath...finally語句

　　4.1. try語句

　　

　　4.2. catch語句

　　

　　咱們通常使用printStackTrace()這個方法來打印異常的信息，使用這個方法打印出來的是全部出錯的信息，包括了使用getMessage()方法打印出來的信息。使用這個方法以前要new一個錯誤對象出來才能調用它。由於它是專屬於某個錯誤對象裏面的方法。

　　4.3. finally語句

　　

　　4.4.異常簡單測試

 1 package cn.javastudy.summary;  2 
 3 import java.io.FileInputStream;  4 import java.io.FileNotFoundException;  5 import java.io.IOException;  6 
 7 public class TestException {  8     
 9     /**
 10  * 任何方法往外拋能處理的異常的時候都有一種簡單的寫法：「throws Exception」，  11  * 由於Exception類是全部能處理的異常類的根基類，所以拋出Exception類就會拋出全部可以被處理的異常類裏了。  12  * 使用「throws Exception」拋出全部能被處理的異常以後，這些被拋出來的異常就是交給JAVA運行時系統處理了，  13  * 而處理的方法是把這些異常的相關錯誤堆棧信息所有打印出來。  14  * @throws Exception  15      */
 16     void fn() throws Exception {  17         
 18  }  19     
 20     /**
 21  * 在知道異常的類型之後，方法聲明時使用throws把異常往外拋  22  * @param i  23  * @throws ArithmeticException  24      */
 25     void m1(int i)  throws ArithmeticException {  26         
 27  }  28     
 29     void m2(int i) {  30         if (i == 0) {  31             //這種作法就是手動拋出異常，使用「throw+new出來的異常對象」就能夠把這個異常對象拋出去了。  32             //這裏是new了一個異常對象，在構建這個對象的時候還能夠指定他相關的信息，如這裏指明瞭異常信息「i不能等於0」  33             //這個對象拋出去的時候使用getMessage()方法拿到的就是「i不能等於0」這種信息。
 34             throw new ArithmeticException("i不能等於0");  35  }  36  }  37     
 38     /**
 39  * 正常狀況下若是這裏不寫try……catch語句那麼程序編譯時必定會報錯，  40  * 由於這裏有可能會產生兩個個必需要處理的異常：FileNotFoundException和IOException。  41  * 但因爲在聲明方法f()時已經使用throws把可能產生的這兩個異常拋出了，  42  * 因此這裏能夠不寫try……catch語句去處理可能會產生的異常。  43  * f()方法把拋出的異常交給下一個要調用它的方法去處理  44  * @throws FileNotFoundException  45  * @throws IOException  46      */
 47     void f() throws FileNotFoundException, IOException {  48         //這裏有可能會產生FileNotFoundException異常
 49         FileInputStream fis = new FileInputStream("MyFile.txt");  50         //這裏有可能會產生IOException異常
 51         int b = fis.read();  52         while (b != -1) {  53             System.out.println((char)b);  54             b = fis.read();  55  }  56  }  57     
 58     /**
 59  * 在f2()方法裏面調用f()方法時必需要處理f()方法拋出來的異常，  60  * 固然，若是f2()方法也沒有辦法處理f()方法拋出來的異常，那麼f2()方法也可使用throws把異常拋出，  61  * 交給下一個調用了f2()的方法去處理f()方法拋出來的異常。  62  * 這裏f2()調用f()方法時，選擇不處理f()方法中可能拋出的異常，將異常繼續拋出  63  * @throws Exception  64      */
 65     void f2() throws Exception {  66  f();  67  }  68     
 69     /**
 70  * f3方法調用f方法捕獲f()方法拋出的2個異常並進行處理  71      */
 72     void f3() {  73         try {  74  f();  75         } catch (FileNotFoundException e) {  76             System.out.println(e.getMessage());//處理的方法是把錯誤信息打印出來
 77         } catch (IOException e) {  78             e.printStackTrace();//處理的方法是使用printStackTrace()方法把錯誤的堆棧信息所有打印出來。
 79  }  80  }  81     
 82     public static void main(String[] args) {  83         FileInputStream fis = null;  84         try {  85             fis = new FileInputStream("MyFile.txt");  86             int b = fis.read();//這個有可能會拋出IOException異常
 87             while (b != -1) {  88                 System.out.println((char)b);  89                 b = fis.read();  90  }  91         } catch (FileNotFoundException e) {  92             //使用catch捕獲FileNotFoundException類異常的異常對象e。並讓異常對象e本身調用printStackTrace方法打印出所有的錯誤信息
 93  e.printStackTrace();  94         } catch (IOException e) {  95             //再次使用catch捕獲IOException類的異常對象e，並讓異常對象e本身調用getMessage()方法將錯誤信息打印出來。
 96  System.out.println(e.getMessage());;  97         }finally{  98             try {  99                 /**
100  * 前面已經把一個文件打開了，無論打開這個文件時有沒有錯誤發生，即有沒有產生異常，最後都必定要把這個文件關閉掉， 101  * 所以使用了finally語句，在finally語句裏面無論前面這個文件打開時是否產生異常，在finally這裏執行in.close()都能把這個文件關閉掉， 102  * 關閉文件也有可能會產生異常，所以在finally裏面也使用了try……catch語句去捕獲有可能產生的異常。 103                  */
104  fis.close(); 105             } catch (IOException e) { 106  e.printStackTrace(); 107  } 108  } 109  } 110 }

5、聲明並拋出異常

6、使用自定義異常

　　

6.1. 自定義異常

 1 package cn.javastudy.summary;  2 
 3 /**
 4  * 自定義的一個異常類MyException，且是從Exception類繼承而來  5  */
 6 public class MyException extends Exception {  7 
 8     private int id;  9 
10     /**
11  * 自定義異常類的構造方法 12  * @param message 13  * @param id 14      */
15     public MyException(String message,int id) { 16         super(message);//調用父類Exception的構造方法
17         this.id = id; 18  } 19     
20     /**
21  * 獲取異常的代碼 22  * @return
23      */
24     public int getId() { 25         return id; 26  } 27     
28 }

6.2.自定義異常測試

 1 package cn.javastudy.summary;  2 
 3 import java.text.MessageFormat;  4 
 5 public class TestMyException {  6 
 7     //throws MyException,拋出咱們自定義的MyException類的異常。
 8     public void regist(int num) throws MyException {  9         if (num < 0) { 10             //使用throw手動拋出一個MyException類的異常對象。
11             throw new MyException("人數爲負值，不合理", 1); 12  } 13         /**
14  * 注意：當咱們拋出了異常以後， 15  * System.out.println(MessageFormat.format("登記人數：{0}",num));是不會被執行的。 16  * 拋出異常以後整個方法的調用就結束了。 17          */
18         System.out.println(MessageFormat.format("登記人數：{0}",num)); 19  } 20     
21     public void manage() { 22         try { 23             regist(-100); 24         } catch (MyException e) { 25             System.out.println("登記失敗，錯誤碼："+e.getId()); 26  e.printStackTrace(); 27  } 28         System.out.println("操做結束"); 29  } 30     
31     
32     public static void main(String[] args) { 33         TestMyException t = new TestMyException(); 34  t.manage(); 35  } 36 
37 }

測試結果：

　　

7、異常處理總結

　　

　　養成良好的編程習慣，不要把錯誤給吞噬掉（即捕獲到異常之後又不作出相應處理的作法，這種作法至關因而把錯誤隱藏起來了，可實際上錯誤依然仍是存在的）， 也不要輕易地往外拋錯誤，能處理的必定要處理，不能處理的必定要往外拋。往外拋的方法有兩種，一種是在知道異常的類型之後，方法聲明時使用throws把 異常往外拋，另外一種是手動往外拋，使用「throw+異常對象」你至關因而把這個異常對象拋出去了，而後在方法的聲明寫上要拋的那種異常。