005 異常處理 java基礎學習總結——異常處理
java基礎學習總結——異常處理
一、異常的概念
異常指的是執行期出現的錯誤，也就是當程式開始執行以後執行期出現的錯誤。出現錯誤時觀察錯誤的名字和行號最為重要。
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宣告的可能出現的異常一定要去捕獲。
二、異常的分類
三、異常的捕獲和處理
Java異常處理的五個關鍵字：try、catch、finally、throw、throws
當捕獲到異常以後一定要做出處理，哪怕是把這個異常的錯誤資訊打印出來，這是一種良好的程式設計習慣。如果不處理，那就是把這個錯誤悄悄地隱藏起來了，可是這個錯誤依然是存在的，只不過看不到了而已。這是一種非常危險的程式設計習慣，絕對不能這樣做，捕獲到異常就一定要做出處理，實在處理不了就把異常丟擲去，讓別的方法去處理。總之就是不能捕獲到異常之後卻又不做出相應的處理，這是一種非常不好的程式設計習慣。
任何方法往外拋能處理的異常的時候都有一種簡單的寫法：“throws Exception”，因為Exception類是所有能處理的異常類的根基類，因此丟擲Exception類就會丟擲所有能夠被處理的異常類裡了。使用“throws Exception”丟擲所有能被處理的異常之後，這些被丟擲來的異常就是交給JAVA執行時系統處理了，而處理的方法是把這些異常的相關錯誤堆疊資訊全部打印出來。除了在做測試以外，在實際當中程式設計的時候，在main方法裡拋Exception是一個非常不好的程式設計習慣，應該使用try……catch去捕獲異常並處理掉捕獲後的異常。不能直接在main方法裡把Exception丟擲去交給JAVA執行時系統出力就完事了，這是一種不負責任的表現。如果想把程式寫得特別健壯，使用try……catch去捕獲異常並處理掉捕獲後的異常是必不可少的做法。
四、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 }
五、宣告並丟擲異常
六、使用自定義異常
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 }
測試結果：
七、異常處理總結
養成良好的程式設計習慣，不要把錯誤給吞噬掉（即捕獲到異常以後又不做出相應處理的做法，這種做法相當於是把錯誤隱藏起來了，可實際上錯誤依然還是存在的）， 也不要輕易地往外拋錯誤，能處理的一定要處理，不能處理的一定要往外拋。往外拋的方法有兩種，一種是在知道異常的型別以後，方法宣告時使用throws把 異常往外拋，另一種是手動往外拋，使用“throw+異常物件”你相當於是把這個異常物件丟擲去了，然後在方法的宣告寫上要拋的那種異常。
一、異常的概念
異常指的是執行期出現的錯誤，也就是當程式開始執行以後執行期出現的錯誤。出現錯誤時觀察錯誤的名字和行號最為重要。
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宣告的可能出現的異常一定要去捕獲。
二、異常的分類
三、異常的捕獲和處理
Java異常處理的五個關鍵字：try、catch、finally、throw、throws
當捕獲到異常以後一定要做出處理，哪怕是把這個異常的錯誤資訊打印出來，這是一種良好的程式設計習慣。如果不處理，那就是把這個錯誤悄悄地隱藏起來了，可是這個錯誤依然是存在的，只不過看不到了而已。這是一種非常危險的程式設計習慣，絕對不能這樣做，捕獲到異常就一定要做出處理，實在處理不了就把異常丟擲去，讓別的方法去處理。總之就是不能捕獲到異常之後卻又不做出相應的處理，這是一種非常不好的程式設計習慣。
任何方法往外拋能處理的異常的時候都有一種簡單的寫法：“throws Exception”，因為Exception類是所有能處理的異常類的根基類，因此丟擲Exception類就會丟擲所有能夠被處理的異常類裡了。使用“throws Exception”丟擲所有能被處理的異常之後，這些被丟擲來的異常就是交給JAVA執行時系統處理了，而處理的方法是把這些異常的相關錯誤堆疊資訊全部打印出來。除了在做測試以外，在實際當中程式設計的時候，在main方法裡拋Exception是一個非常不好的程式設計習慣，應該使用try……catch去捕獲異常並處理掉捕獲後的異常。不能直接在main方法裡把Exception丟擲去交給JAVA執行時系統出力就完事了，這是一種不負責任的表現。如果想把程式寫得特別健壯，使用try……catch去捕獲異常並處理掉捕獲後的異常是必不可少的做法。
四、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 }
五、宣告並丟擲異常
六、使用自定義異常
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 }
測試結果：
七、異常處理總結
養成良好的程式設計習慣，不要把錯誤給吞噬掉（即捕獲到異常以後又不做出相應處理的做法，這種做法相當於是把錯誤隱藏起來了，可實際上錯誤依然還是存在的）， 也不要輕易地往外拋錯誤，能處理的一定要處理，不能處理的一定要往外拋。往外拋的方法有兩種，一種是在知道異常的型別以後，方法宣告時使用throws把 異常往外拋，另一種是手動往外拋，使用“throw+異常物件”你相當於是把這個異常物件丟擲去了，然後在方法的宣告寫上要拋的那種異常。