Java中的異常處理機制

異常機制已成為判斷1門編程語言是不是成熟的標準，異常機制可使程序中異常處理代碼和正常業務代碼分離，保證程序代碼更加優雅，并提高程序硬朗性。

         Java異常機制主要依賴于try、catch、finally、throw、throws5個關鍵字。

         1.try：它里面放置可能引發異常的代碼

         2.catch：后面對應異常類型和1個代碼塊，用于表明該catch塊用于處理這類類型的代碼塊，可以有多個catch塊。

         3.finally：主要用于回收在try塊里打開的物力資源（如數據庫連接、網絡連接和磁盤文件），異常機制總是保證finally塊總是被履行。只有finally塊，履行完成以后，才會回來履行try或catch塊中的return或throw語句，如果finally中使用了return或   throw等終止方法的語句，則就不會跳回履行，直接停止。

         4.throw：用于拋出1個實際的異常，可以單獨作為語句使用，拋出1個具體的異常對象。

         5.throws：用在方法簽名中，用于聲明該方法可能拋出的異常。

       Java的異常分為兩種，checked異常（編譯時異常）和Runtime異常（運行時異常）

1.       java認為checked異常都是可以再編譯階段被處理的異常，所以它強迫程序處理所有的checked異常，而Runtime異常不必處理，java程序必須顯式處理checked異常，如果程序沒有處理，則在編譯時會產生毛病，沒法通過編譯。

2.       checked異常體現了java設計哲學：沒有完善處理的代碼根本不會被履行，體現了java的嚴謹性，

     對構造大型、硬朗、可保護的利用系統而言，毛病處理是全部利用需要斟酌的重要方面。Java異常處理機制，在程序運行出現意外時，系統會生成1個Exception對象，來通知程序，從而實現將“業務功能實現代碼”和“毛病處理代碼”分離，提供更好的可讀性。

     如果履行try塊里的業務邏輯代碼時出現異常，系統會自動生成1個異常對象，該異常對象被提交給運行環境，這個進程被稱為拋出（throw）異常。Java環境收到異常對象時，會尋覓適合的catch塊，如果找不到，java運行環境就會終止，java程序將退出。

     不同的catch塊，視為了針對不同的異常類，提供不同的處理方法。

對毛病處理機制，主要有以下的兩個缺點：

1.沒法窮舉所有異常情況：由于人類的知識是有限的，異常情況總比可以斟酌到的情況多，總有漏網之魚

2.毛病處理代碼和業務實現代碼混雜嚴重影響程序的可讀性，會增加程序保護的難度。

1.使用try...catch捕獲異常

java提出了1種假定，如果程序可以順利完成，那末1切正常，把系統的業務實現代碼放在try塊中定義，所有的異常處理邏輯放在catch塊中進行處理。

即：try{

//業務實現代碼

...

}

catch(Exception e){

輸入不合法

}

上面的格式中try塊和catch塊后的{...}都是不可以省略的！

履行步驟：

1.如果履行try塊中的業務邏輯代碼時出現異常，系統自動生成1個異常對象，該異常對象被提交給java運行環境，這個進程稱為拋出（throw）異常。

2.當java運行環境收到異常對象時，會尋覓能處理該異常對象的catch塊，如果找到適合的cathc塊并把該異常對象交給catch塊處理，那這個進程稱為捕獲（catch）異常；如果java運行時環境找不到捕獲異常的catch塊，則運行時環境終止，jav程序也將退出。

注意1：不管程序代碼塊是不是處于try塊中，乃至包括catch塊中代碼，只要履行該代碼時出現了異常，系統都會自動生成1個異常對象，如果程序沒有為這段代碼定義任何catch塊，java運行環境肯定找不到處理該異常的catch塊，程序肯定在此退出。

注意2：try塊后可以有多個catch塊，try塊后使用多個catch塊是為了針對不同異常類提供的不同的異常處理方式。當系統產生不同意外情況時，系統會生成不同的異常對象，java運行時就會根據該異常對象所屬的異常類來決定使用哪一個catch塊來處理該異常。

注意3：通常情況下，如果try塊被履行1次，則try塊后只有1個catch塊會被履行，絕不可能有多個catch塊被履行，除非在循環中使用類continue開始下1次循環，下1次循環又重新運行了try塊，這才可能致使多個catch塊被履行。

注意4：進行異常捕獲時，1定要記住先捕獲小的異常，再捕獲大的異常。

Java的異常類，和他們的繼承關系：

 java把所有非正常情況分成兩種：異常（Exception）和毛病（Error），都是繼承自Throwable父類。

 Error毛?。?/span>1般是指虛擬機相干的問題，如系統崩潰，虛擬機出毛病等，這類毛病沒法恢復或不可能捕獲，將致使利用程序中斷，通常不處理。

         Throwable（）：Throwable 類是 Java 語言中所有毛病或異常的超類。只有當對象是此類（或其子類之1）的實例時，才能通過 Java 虛擬機或 Java throw 語句拋出。類似地，只有此類或其子類之1才可以是 catch 子句中的參數類型。

         1.Error（毛?。?/span>：1般是指java虛擬機相干的問題，如系統崩潰、虛擬機出毛病、動態鏈接失敗等，這類毛病沒法恢復或不可能捕獲，將致使利用程序中斷，通常利用程序沒法處理這些毛病，因此利用程序不應當捕獲Error對象，也不必在其throws子句中聲明該方法拋出任何Error或其子類。

         2.Exception：Exception 類及其子類是 Throwable 的1種情勢，它指出了公道的利用程序想要捕獲的條件

         （1）. SQLException：該異常提供關于數據庫訪問毛病或其他毛病的信息。

         （2）. RuntimeException 是那些可能在 Java 虛擬機正常運行期間拋出的異常的超類

         （3）.IOException：此類為異常的通用類，它是由失敗的或中斷的 I/O 操作生成的。

異常對象包括的經常使用方法：

1.       getMessage（）；返回該異常的詳細描寫字符

2.       printStackTrace（）：將該異常的跟蹤棧信息輸出到標準毛病輸出。

3.       printStackTrace（PrintStream s）：將該異常的跟蹤棧信息輸出到指定的輸出流

4.       getStackTrace（）：返回該異常的跟蹤棧信息。

 1 public class TestException
 2 {
 3 
 4 public static void main(String[] args)
 5 {
 6 
 7     try{
 8         FileInputStream fis=new FileInputStream("a.txt");
 9        }
10     catch(IOException ioe)
11     {
12         System.out.println(ioe.getMessage());
13         ioe.printStackTrace();
14     }
15 
16 }
17 
18 }

使用finally回收資源

 有時候，程序在try塊里面打開了1些物力資源（比如數據庫連接，網絡連接好磁盤文件等），這些物理資源都必須顯式回收。

由于：java的垃圾回收機制不會回收任何的物理資源，垃圾回收機制只回收堆內存中對象所占用的內存。

問題1：那末在哪邊回收這些物理資源呢？

答：在finally塊中，由于如果try塊的某條語句引發1場，該語句后的其他語句通常不會被履行，那將致使位于該語句后的資源回收語句得不到履行；如果在catch塊里進行資源回收，但catch塊完全有可能得不到履行，這也將致使不能及時回收這些物理資源。所以我們不管try塊中的代碼是不是出現異常，也不管哪一個catch塊會被履行，finally塊總會被履行。

那末：java異常處理的完全語法結構以下：

try
{
     //業務實現邏輯
     ...
}
catch（SubException e）
{
     //異常處理快1
     ...
}
catch（SubException2 e）
{
     //異常處理快2
     ...
}
     ...
finally
{
    //資源回收塊
    ...
}

以上的異常處理語法結構中
注意點1：只有try塊石必須的，也就是說如果沒有try塊，則不可能有后面的catch塊和finally塊；
注意點2：catch塊和finally塊都是可選的，但catch塊和finally塊最少出現其中之1，也能夠同時出現；
注意點3：可以有多個catch塊，捕獲父類異常的catch塊必須位于捕獲子類異常的后面；
注意點4：不能只有try塊，既沒有catch塊，也沒有finally塊；
注意點5：多個catch塊必須位于try塊以后，finally塊必須位于所有catch塊以后。

 1 import java.io.FileInputStream;
 2 import java.io.IOException;
 3 
 4 public class TestException
 5 {
 6 
 7     /**
 8      * @param args
 9      */
10     public static void main(String[] args)
11     {
12         // TODO Auto-generated method stub
13         FileInputStream fis = null;
14         try
15         {
16             fis = new FileInputStream("a.txt");
17         } catch (IOException ioe)
18         {
19             System.out.println(ioe.getMessage());
20             // return語句強迫方法返回
21             return;
22             // 使用exit來退出虛擬機
23             // System.exit(1);
24         } finally
25         {
26             // 關閉磁盤文件，回收資源
27             if (fis != null)
28             {
29                 try
30                 {
31                     fis.close();
32                 } catch (IOException ioe)
33                 {
34                     ioe.printStackTrace();
35                 }
36             }
37             System.out.println("程序已履行了finally里德資源回收");
38         }
39     }
40 
41 }

運行程序結果：
a.txt (系統找不到指定的文件。)
程序已履行了finally里德資源回收

如果將catch塊中的最后兩句注釋放入程序，那末結果為：a.txt (系統找不到指定的文件。)

 以上兩種情況顯示：除非在try塊或catch塊中調用了退出虛擬機的方法（即System.exit(1);），否則不管在try塊、catch塊中履行怎樣的代碼，出現怎樣的情況，異常處理的finally塊總是會被履行的。不過，1般情況下，不要再finally塊中使用renturn或throw等致使方法終止的語句，由于1旦使用，將會致使try塊、catch塊中的return、throw語句失效。

 1 public class TestException1
 2 {
 3 
 4     public static boolean test()
 5     {
 6         try
 7         {
 8             return true;
 9         } finally
10         {
11             return false;
12         }
13     }
14 
15     public static void main(String[] args)
16     {
17         boolean a = test();
18         System.out.println(a);
19     }
20 
21 }

運行結果：false

以上的小程序說明：在finally塊中定義了1個renturn false語句，這將致使try塊中的return true 失去作用！

總結1下這個小問題：

當程序履行try塊，catch塊時遇到return語句或throw語句，這兩個語句都會致使該方法立即結束，所以系統其實不會立即履行這兩個語句，而是去尋覓該異常處理流程中的finally塊，如果沒有finally塊，程序立即履行return語句或throw語句，方法終止。如果有finally塊，系統立即開始履行finally塊，只有當finally塊履行完成后，系統才會再次跳回來履行try塊、catch塊里的return或throw語句，如果finally塊里也使用了return或throw等致使方法終止的語句，則finally塊已終止了方法，不用再跳回去履行try塊、catch塊里的任何代碼了。

綜上：盡可能避免在finally塊里使用return或throw等致使方法終止的語句，否則可能出現1些很奇怪的情況！

異常處理的嵌套

例如catch塊中再次包括了1個完全的異常處理流程，這類在try塊，catch塊或finally塊中包括完全的異常處理流程的情形稱為異常處理的嵌套。異常處理流程的代碼可以放在任何可履行代碼的地方，因此完全的異常處理流程既可放在try塊，也可放在catch塊，也可放在finally塊里。

嵌套的深度沒有很明確的限制，通常沒有必要寫層次太深的嵌套異常處理，會致使程序可讀性下降。

 Checked異常和Runtime異常體系

 java異常被分為兩大類：Checked異常和Runtime異常（運行時異常）。

所有RuntimeException類及其子類的實例被稱為Runtime異常，不是RuntimeException類及其子類的異常實例則被稱為Checked異常。

只有java語言提供了Checked異常，其他語言都沒有提供，java認為Checked異常都是可以被處理（修復）的異常，所以java程序不必顯式的處理Checked異常。如果程序沒有處理Checked異常，該程序在編譯時就會產生毛病，沒法通過編譯。

Checked異常的處理方式：

①：當方法明確知道如何處理異常，程序應當使用try...catch塊來捕獲該異常，然后在對應的catch塊中修補該異常。

②：當方法不知道如何處理異常，應當在定義該方法時聲明拋出該異常。

Runtime異常不必顯式聲明拋出，如果程序需要捕捉Runtime異常，也能夠使用try...catch塊來捕獲Runtime異常。

問題是：大部份的方法總是不能明確知道如何處理異常，這就只能聲明拋出異常了。

使用throws拋出異常

使用throws拋出異常的思路是:當前方法不知道如何處理這類類型的異常，該異常應當由上1級調用者處理，如果main方法也不知道應當如何處理這類類型的異常，也能夠使用使用throws聲明拋出異常，該異常將交給JVM來處理。

JVM對異常的處理方法：打印異常跟蹤棧的信息，并終止程序運行，所以有很多程序遇到異常后自動結束。

使用throws拋出異常的格式：

throws聲明的拋出的語法格式緊跟在方法以后，可以聲明多個異常類，多個異常類之間以逗號隔開。1旦使用了throws語句聲明拋出異常，就不用再使用try...catch來捕獲異常了。

如：throws ExceptionClass1,ExceptionClass2...

注意點1:如果某段代碼調用了1個帶throws聲明的方法，該方法聲明拋出了Checked異常，這表明該方法希望它的調用者來處理該異常。那末這段代碼要末放在try塊中顯示捕獲該異常，要末這段代碼處于另外一個帶throws聲明拋出的方法中。

舉例以下：

 1 //方法1：
 2 
 3 import java.io.FileInputStream;
 4 import java.io.IOException;
 5 
 6 public class TestException2
 7 {
 8 
 9     // test() 方法拋出了異常，那末test()方法的調用者要末放在try塊中顯示捕獲該異常，要末這段代碼處于另外一個帶throws聲明拋出的方法中。
10 
11     // 以下為后者的處理方法
12 
13     public static void test() throws IOException
14     {
15         FileInputStream fis = new FileInputStream("a.txt");
16     }
17 
18     public static void main(String[] args) throws Exception
19     {
20         test();
21     }
22 
23 }

 1 //方法2：
 2 
 3 import java.io.FileInputStream;
 4 import java.io.IOException;
 5 
 6 public class TestException2
 7 {
 8 

 生活不易，碼農辛苦

 如果您覺得本網站對您的學習有所幫助,可以手機掃描二維碼進行捐贈