為什麼要使用異常
異常基本定義
異常體系
初識異常
異常和錯誤
異常的處理方式
"不負責任"的throws
糾結的finally
throw : JRE也使用的關鍵字
異常呼叫鏈
自定義異常
異常的注意事項
當finally遇上return
JAVA異常常見面試題
參考文章
微信公眾號
- Java技術江湖
- 個人公眾號：黃小斜

- Java異常

本系列文章將整理到我在GitHub上的《Java面試指南》倉庫，更多精彩內容請到我的倉庫裡檢視

https://github.com/h2pl/Java-Tutorial

喜歡的話麻煩點下Star哈

文章首發於我的個人部落格：

www.how2playlife.com

本文是微信公眾號【Java技術江湖】的《夯實Java基礎系列博文》其中一篇，本文部分內容來源於網路，為了把本文主題講得清晰透徹，也整合了很多我認為不錯的技術部落格內容，引用其中了一些比較好的部落格文章，如有侵權，請聯絡作者。
該系列博文會告訴你如何從入門到進階，一步步地學習Java基礎知識，並上手進行實戰，接著瞭解每個Java知識點背後的實現原理，更完整地瞭解整個Java技術體系，形成自己的知識框架。為了更好地總結和檢驗你的學習成果，本系列文章也會提供每個知識點對應的面試題以及參考答案。

如果對本系列文章有什麼建議，或者是有什麼疑問的話，也可以關注公眾號【Java技術江湖】聯絡作者，歡迎你參與本系列博文的創作和修訂。

為什麼要使用異常

首先我們可以明確一點就是異常的處理機制可以確保我們程式的健壯性，提高系統可用率。雖然我們不是特別喜歡看到它，但是我們不能不承認它的地位，作用。

在沒有異常機制的時候我們是這樣處理的：通過函式的返回值來判斷是否發生了異常（這個返回值通常是已經約定好了的），呼叫該函式的程式負責檢查並且分析返回值。雖然可以解決異常問題，但是這樣做存在幾個缺陷：

1、容易混淆。如果約定返回值為-11111時表示出現異常，那麼當程式最後的計算結果真的為-1111呢？

2、程式碼可讀性差。將異常處理程式碼和程式程式碼混淆在一起將會降低程式碼的可讀性。

3、由呼叫函式來分析異常，這要求程式設計師對庫函式有很深的瞭解。

在OO中提供的異常處理機制是提供程式碼健壯的強有力的方式。使用異常機制它能夠降低錯誤處理程式碼的複雜度，如果不使用異常，那麼就必須檢查特定的錯誤，並在程式中的許多地方去處理它。

而如果使用異常，那就不必在方法呼叫處進行檢查，因為異常機制將保證能夠捕獲這個錯誤，並且，只需在一個地方處理錯誤，即所謂的異常處理程式中。

這種方式不僅節約程式碼，而且把“概述在正常執行過程中做什麼事”的程式碼和“出了問題怎麼辦”的程式碼相分離。總之，與以前的錯誤處理方法相比，異常機制使程式碼的閱讀、編寫和除錯工作更加井井有條。（摘自《Think in java 》）。

該部分內容選自http://www.cnblogs.com/chenssy/p/3438130.html

異常基本定義

在《Think in java》中是這樣定義異常的：異常情形是指阻止當前方法或者作用域繼續執行的問題。在這裡一定要明確一點：異常程式碼某種程度的錯誤，儘管Java有異常處理機制，但是我們不能以“正常”的眼光來看待異常，異常處理機制的原因就是告訴你：這裡可能會或者已經產生了錯誤，您的程式出現了不正常的情況，可能會導致程式失敗！

那麼什麼時候才會出現異常呢？只有在你當前的環境下程式無法正常執行下去，也就是說程式已經無法來正確解決問題了，這時它所就會從當前環境中跳出，並丟擲異常。丟擲異常後，它首先會做幾件事。

首先，它會使用new建立一個異常物件，然後在產生異常的位置終止程式，並且從當前環境中彈出對異常物件的引用，這時。異常處理機制就會接管程式，並開始尋找一個恰當的地方來繼續執行程式，這個恰當的地方就是異常處理程式。

總的來說異常處理機制就是當程式發生異常時，它強制終止程式執行，記錄異常資訊並將這些資訊反饋給我們，由我們來確定是否處理異常。

異常體系

[外鏈圖片轉存失敗(img-KNxcBTK0-1569073569353)(https://images0.cnblogs.com/blog/381060/201311/22185952-834d92bc2bfe498f9a33414cc7a2c8a4.png)]

從上面這幅圖可以看出，Throwable是java語言中所有錯誤和異常的超類（萬物即可拋）。它有兩個子類：Error、Exception。

Java標準庫內建了一些通用的異常，這些類以Throwable為頂層父類。

Throwable又派生出Error類和Exception類。

錯誤：Error類以及他的子類的例項，代表了JVM本身的錯誤。錯誤不能被程式設計師通過程式碼處理，Error很少出現。因此，程式設計師應該關注Exception為父類的分支下的各種異常類。

異常：Exception以及他的子類，代表程式執行時傳送的各種不期望發生的事件。可以被Java異常處理機制使用，是異常處理的核心。

總體上我們根據Javac對異常的處理要求，將異常類分為2類。

非檢查異常（unckecked exception）：Error 和 RuntimeException 以及他們的子類。javac在編譯時，不會提示和發現這樣的異常，不要求在程式處理這些異常。所以如果願意，我們可以編寫程式碼處理（使用try…catch…finally）這樣的異常，也可以不處理。

對於這些異常，我們應該修正程式碼，而不是去通過異常處理器處理。這樣的異常發生的原因多半是程式碼寫的有問題。如除0錯誤ArithmeticException，錯誤的強制型別轉換錯誤ClassCastException，陣列索引越界ArrayIndexOutOfBoundsException，使用了空物件NullPointerException等等。

檢查異常（checked exception）：除了Error 和 RuntimeException的其它異常。javac強制要求程式設計師為這樣的異常做預備處理工作（使用try…catch…finally或者throws）。在方法中要麼用try-catch語句捕獲它並處理，要麼用throws子句宣告丟擲它，否則編譯不會通過。

這樣的異常一般是由程式的執行環境導致的。因為程式可能被執行在各種未知的環境下，而程式設計師無法干預使用者如何使用他編寫的程式，於是程式設計師就應該為這樣的異常時刻準備著。如SQLException , IOException,ClassNotFoundException 等。

需要明確的是：檢查和非檢查是對於javac來說的，這樣就很好理解和區分了。

這部分內容摘自http://www.importnew.com/26613.html

初識異常

異常是在執行某個函式時引發的，而函式又是層級呼叫，形成呼叫棧的，因為，只要一個函式發生了異常，那麼他的所有的caller都會被異常影響。當這些被影響的函式以異常資訊輸出時，就形成的了異常追蹤棧。

異常最先發生的地方，叫做異常丟擲點。

public class 異常 {
    public static void main (String [] args )
    {
        System . out. println( "----歡迎使用命令列除法計算器----" ) ;
        CMDCalculate ();
    }
    public static void CMDCalculate ()
    {
        Scanner scan = new Scanner ( System. in );
        int num1 = scan .nextInt () ;
        int num2 = scan .nextInt () ;
        int result = devide (num1 , num2 ) ;
        System . out. println( "result:" + result) ;
        scan .close () ;
    }
    public static int devide (int num1, int num2 ){
        return num1 / num2 ;
    }

//    ----歡迎使用命令列除法計算器----
//            1
//            0
//    Exception in thread "main" java.lang.ArithmeticException: / by zero
//    at com.javase.異常.異常.devide(異常.java:24)
//    at com.javase.異常.異常.CMDCalculate(異常.java:19)
//    at com.javase.異常.異常.main(異常.java:12)

//  ----歡迎使用命令列除法計算器----
//    r
//    Exception in thread "main" java.util.InputMismatchException
//    at java.util.Scanner.throwFor(Scanner.java:864)
//    at java.util.Scanner.next(Scanner.java:1485)
//    at java.util.Scanner.nextInt(Scanner.java:2117)
//    at java.util.Scanner.nextInt(Scanner.java:2076)
//    at com.javase.異常.異常.CMDCalculate(異常.java:17)
//    at com.javase.異常.異常.main(異常.java:12)

[外鏈圖片轉存失敗(img-9rqUQJQj-1569073569354)(http://incdn1.b0.upaiyun.com/2017/09/0b3e4ca2f4cf8d7116c7ad354940601f.png)]

從上面的例子可以看出，當devide函式發生除0異常時，devide函式將丟擲ArithmeticException異常，因此呼叫他的CMDCalculate函式也無法正常完成，因此也傳送異常，而CMDCalculate的caller——main 因為CMDCalculate丟擲異常，也發生了異常，這樣一直向呼叫棧的棧底回溯。

這種行為叫做異常的冒泡，異常的冒泡是為了在當前發生異常的函式或者這個函式的caller中找到最近的異常處理程式。由於這個例子中沒有使用任何異常處理機制，因此異常最終由main函式拋給JRE，導致程式終止。

上面的程式碼不使用異常處理機制，也可以順利編譯，因為2個異常都是非檢查異常。但是下面的例子就必須使用異常處理機制，因為異常是檢查異常。

程式碼中我選擇使用throws宣告異常，讓函式的呼叫者去處理可能發生的異常。但是為什麼只throws了IOException呢？因為FileNotFoundException是IOException的子類，在處理範圍內。

異常和錯誤

下面看一個例子

//錯誤即error一般指jvm無法處理的錯誤
//異常是Java定義的用於簡化錯誤處理流程和定位錯誤的一種工具。
public class 錯誤和錯誤 {
    Error error = new Error();

    public static void main(String[] args) {
        throw new Error();
    }

    //下面這四個異常或者錯誤有著不同的處理方法
    public void error1 (){
        //編譯期要求必須處理，因為這個異常是最頂層異常，包括了檢查異常，必須要處理
        try {
            throw new Throwable();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }
    //Exception也必須處理。否則報錯，因為檢查異常都繼承自exception，所以預設需要捕捉。
    public void error2 (){
        try {
            throw new Exception();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //error可以不處理，編譯不報錯,原因是虛擬機器根本無法處理，所以啥都不用做
    public void error3 (){
        throw new Error();
    }

    //runtimeexception眾所周知編譯不會報錯
    public void error4 (){
        throw new RuntimeException();
    }
//    Exception in thread "main" java.lang.Error
//    at com.javase.異常.錯誤.main(錯誤.java:11)

}

異常的處理方式

在編寫程式碼處理異常時，對於檢查異常，有2種不同的處理方式：

使用try…catch…finally語句塊處理它。

或者，在函式簽名中使用throws 宣告交給函式呼叫者caller去解決。

下面看幾個具體的例子，包括error，exception和throwable

上面的例子是執行時異常，不需要顯示捕獲。
下面這個例子是可檢查異常需，要顯示捕獲或者丟擲。

@Test
public void testException() throws IOException
{
    //FileInputStream的建構函式會丟擲FileNotFoundException
    FileInputStream fileIn = new FileInputStream("E:\\a.txt");

    int word;
    //read方法會丟擲IOException
    while((word =  fileIn.read())!=-1)
    {
        System.out.print((char)word);
    }
    //close方法會丟擲IOException
    fileIn.close();
}

一般情況下的處理方式 try catch finally

public class 異常處理方式 {

@Test
public void main() {
    try{
        //try塊中放可能發生異常的程式碼。
        InputStream inputStream = new FileInputStream("a.txt");

        //如果執行完try且不發生異常，則接著去執行finally塊和finally後面的程式碼（如果有的話）。
        int i = 1/0;
        //如果發生異常，則嘗試去匹配catch塊。
        throw new SQLException();
        //使用1.8jdk同時捕獲多個異常，runtimeexception也可以捕獲。只是捕獲後虛擬機器也無法處理，所以不建議捕獲。
    }catch(SQLException | IOException | ArrayIndexOutOfBoundsException exception){
        System.out.println(exception.getMessage());
        //每一個catch塊用於捕獲並處理一個特定的異常，或者這異常型別的子類。Java7中可以將多個異常宣告在一個catch中。

        //catch後面的括號定義了異常型別和異常引數。如果異常與之匹配且是最先匹配到的，則虛擬機器將使用這個catch塊來處理異常。

        //在catch塊中可以使用這個塊的異常引數來獲取異常的相關資訊。異常引數是這個catch塊中的區域性變數，其它塊不能訪問。

        //如果當前try塊中發生的異常在後續的所有catch中都沒捕獲到，則先去執行finally，然後到這個函式的外部caller中去匹配異常處理器。

        //如果try中沒有發生異常，則所有的catch塊將被忽略。

    }catch(Exception exception){
        System.out.println(exception.getMessage());
        //...
    }finally{
        //finally塊通常是可選的。
        //無論異常是否發生，異常是否匹配被處理，finally都會執行。

        //finally主要做一些清理工作，如流的關閉，資料庫連線的關閉等。
    }

一個try至少要跟一個catch或者finally

    try {
        int i = 1;
    }finally {
        //一個try至少要有一個catch塊，否則， 至少要有1個finally塊。但是finally不是用來處理異常的，finally不會捕獲異常。
    }
}

異常出現時該方法後面的程式碼不會執行，即使異常已經被捕獲。這裡舉出一個奇特的例子，在catch裡再次使用try catch finally

@Test
public void test() {
    try {
        throwE();
        System.out.println("我前面丟擲異常了");
        System.out.println("我不會執行了");
    } catch (StringIndexOutOfBoundsException e) {
        System.out.println(e.getCause());
    }catch (Exception ex) {
    //在catch塊中仍然可以使用try catch finally
        try {
            throw new Exception();
        }catch (Exception ee) {
            
        }finally {
            System.out.println("我所在的catch塊沒有執行，我也不會執行的");
        }
    }
}
//在方法宣告中丟擲的異常必須由呼叫方法處理或者繼續往上拋，
// 當拋到jre時由於無法處理終止程式
public void throwE (){
//        Socket socket = new Socket("127.0.0.1", 80);

        //手動丟擲異常時，不會報錯，但是呼叫該方法的方法需要處理這個異常，否則會出錯。
//        java.lang.StringIndexOutOfBoundsException
//        at com.javase.異常.異常處理方式.throwE(異常處理方式.java:75)
//        at com.javase.異常.異常處理方式.test(異常處理方式.java:62)
        throw new StringIndexOutOfBoundsException();
    }

其實有的語言在遇到異常後仍然可以繼續執行

有的程式語言當異常被處理後，控制流會恢復到異常丟擲點接著執行，這種策略叫做：resumption model of exception handling（恢復式異常處理模式）

而Java則是讓執行流恢復到處理了異常的catch塊後接著執行，這種策略叫做：termination model of exception handling（終結式異常處理模式）

"不負責任"的throws

throws是另一種處理異常的方式，它不同於try…catch…finally，throws僅僅是將函式中可能出現的異常向呼叫者宣告，而自己則不具體處理。

採取這種異常處理的原因可能是：方法本身不知道如何處理這樣的異常，或者說讓呼叫者處理更好，呼叫者需要為可能發生的異常負責。

public void foo() throws ExceptionType1 , ExceptionType2 ,ExceptionTypeN
{ 
     //foo內部可以丟擲 ExceptionType1 , ExceptionType2 ,ExceptionTypeN 類的異常，或者他們的子類的異常物件。
}

糾結的finally

finally塊不管異常是否發生，只要對應的try執行了，則它一定也執行。只有一種方法讓finally塊不執行：System.exit()。因此finally塊通常用來做資源釋放操作：關閉檔案，關閉資料庫連線等等。

良好的程式設計習慣是：在try塊中開啟資源，在finally塊中清理釋放這些資源。

需要注意的地方:

1、finally塊沒有處理異常的能力。處理異常的只能是catch塊。

2、在同一try…catch…finally塊中，如果try中丟擲異常，且有匹配的catch塊，則先執行catch塊，再執行finally塊。如果沒有catch塊匹配，則先執行finally，然後去外面的呼叫者中尋找合適的catch塊。

3、在同一try…catch…finally塊中，try發生異常，且匹配的catch塊中處理異常時也丟擲異常，那麼後面的finally也會執行：首先執行finally塊，然後去外圍呼叫者中尋找合適的catch塊。

public class finally使用 {
    public static void main(String[] args) {
        try {
            throw new IllegalAccessException();
        }catch (IllegalAccessException e) {
            // throw new Throwable();
            //此時如果再拋異常，finally無法執行，只能報錯。
            //finally無論何時都會執行
            //除非我顯示呼叫。此時finally才不會執行
            System.exit(0);

        }finally {
            System.out.println("算你狠");
        }
    }
}

throw : JRE也使用的關鍵字

throw exceptionObject

程式設計師也可以通過throw語句手動顯式的丟擲一個異常。throw語句的後面必須是一個異常物件。

throw 語句必須寫在函式中，執行throw 語句的地方就是一個異常丟擲點，==它和由JRE自動形成的異常丟擲點沒有任何差別。==

public void save(User user)
{
      if(user  == null) 
          throw new IllegalArgumentException("User物件為空");
      //......
 
}

後面開始的大部分內容都摘自http://www.cnblogs.com/lulipro/p/7504267.html

該文章寫的十分細緻到位，令人欽佩，是我目前為之看到關於異常最詳盡的文章，可以說是站在巨人的肩膀上了。

異常呼叫鏈

異常的鏈化

在一些大型的，模組化的軟體開發中，一旦一個地方發生異常，則如骨牌效應一樣，將導致一連串的異常。假設B模組完成自己的邏輯需要呼叫A模組的方法，如果A模組發生異常，則B也將不能完成而發生異常。

==但是B在丟擲異常時，會將A的異常資訊掩蓋掉，這將使得異常的根源資訊丟失。異常的鏈化可以將多個模組的異常串聯起來，使得異常資訊不會丟失。==

異常鏈化:以一個異常物件為引數構造新的異常物件。新的異物件將包含先前異常的資訊。這項技術主要是異常類的一個帶Throwable引數的函式來實現的。這個當做引數的異常，我們叫他根源異常（cause）。

檢視Throwable類原始碼，可以發現裡面有一個Throwable欄位cause，就是它儲存了構造時傳遞的根源異常引數。這種設計和連結串列的結點類設計如出一轍，因此形成鏈也是自然的了。

public class Throwable implements Serializable {
    private Throwable cause = this;
 
    public Throwable(String message, Throwable cause) {
        fillInStackTrace();
        detailMessage = message;
        this.cause = cause;
    }
     public Throwable(Throwable cause) {
        fillInStackTrace();
        detailMessage = (cause==null ? null : cause.toString());
        this.cause = cause;
    }
 
    //........
}

下面看一個比較實在的異常鏈例子哈

public class 異常鏈 {
    @Test
    public void test() {
        C();
    }
    public void A () throws Exception {
        try {
            int i = 1;
            i = i / 0;
            //當我註釋掉這行程式碼並使用B方法丟擲一個error時，執行結果如下
//            四月 27, 2018 10:12:30 下午 org.junit.platform.launcher.core.ServiceLoaderTestEngineRegistry loadTestEngines
//            資訊: Discovered TestEngines with IDs: [junit-jupiter]
//            java.lang.Error: B也犯了個錯誤
//            at com.javase.異常.異常鏈.B(異常鏈.java:33)
//            at com.javase.異常.異常鏈.C(異常鏈.java:38)
//            at com.javase.異常.異常鏈.test(異常鏈.java:13)
//            at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
//            Caused by: java.lang.Error
//            at com.javase.異常.異常鏈.B(異常鏈.java:29)

        }catch (ArithmeticException e) {
            //這裡通過throwable類的構造方法將最底層的異常重新包裝並丟擲，此時注入了A方法的資訊。最後列印棧資訊時可以看到caused by
            A方法的異常。
            //如果直接丟擲，棧資訊列印結果只能看到上層方法的錯誤資訊，不能看到其實是A發生了錯誤。
            //所以需要包裝並丟擲
            throw new Exception("A方法計算錯誤", e);
        }

    }
    public void B () throws Exception,Error {
        try {
            //接收到A的異常，
            A();
            throw new Error();
        }catch (Exception e) {
            throw e;
        }catch (Error error) {
            throw new Error("B也犯了個錯誤", error);
        }
    }
    public void C () {
        try {
            B();
        }catch (Exception | Error e) {
            e.printStackTrace();
        }

    }

    //最後結果
//    java.lang.Exception: A方法計算錯誤
//    at com.javase.異常.異常鏈.A(異常鏈.java:18)
//    at com.javase.異常.異常鏈.B(異常鏈.java:24)
//    at com.javase.異常.異常鏈.C(異常鏈.java:31)
//    at com.javase.異常.異常鏈.test(異常鏈.java:11)
//    省略
//    Caused by: java.lang.ArithmeticException: / by zero
//    at com.javase.異常.異常鏈.A(異常鏈.java:16)
//            ... 31 more
}

自定義異常

如果要自定義異常類，則擴充套件Exception類即可，因此這樣的自定義異常都屬於檢查異常（checked exception）。如果要自定義非檢查異常，則擴充套件自RuntimeException。

按照國際慣例，自定義的異常應該總是包含如下的建構函式：

一個無參建構函式
一個帶有String引數的建構函式，並傳遞給父類的建構函式。
一個帶有String引數和Throwable引數，並都傳遞給父類建構函式
一個帶有Throwable 引數的建構函式，並傳遞給父類的建構函式。
下面是IOException類的完整原始碼，可以借鑑。

public class IOException extends Exception
{
    static final long serialVersionUID = 7818375828146090155L;
 
    public IOException()
    {
        super();
    }
 
    public IOException(String message)
    {
        super(message);
    }
 
    public IOException(String message, Throwable cause)
    {
        super(message, cause);
    }
 
    public IOException(Throwable cause)
    {
        super(cause);
    }
}

異常的注意事項

當子類重寫父類的帶有 throws宣告的函式時，其throws宣告的異常必須在父類異常的可控範圍內——用於處理父類的throws方法的異常處理器，必須也適用於子類的這個帶throws方法。這是為了支援多型。

例如，父類方法throws 的是2個異常，子類就不能throws 3個及以上的異常。父類throws IOException，子類就必須throws IOException或者IOException的子類。

至於為什麼？我想，也許下面的例子可以說明。

class Father
{
    public void start() throws IOException
    {
        throw new IOException();
    }
}
 
class Son extends Father
{
    public void start() throws Exception
    {
        throw new SQLException();
    }
}

/**********************假設上面的程式碼是允許的（實質是錯誤的）***********************/

class Test
{
    public static void main(String[] args)
    {
        Father[] objs = new Father[2];
        objs[0] = new Father();
        objs[1] = new Son();
 
        for(Father obj:objs)
        {
        //因為Son類丟擲的實質是SQLException，而IOException無法處理它。
        //那麼這裡的try。。catch就不能處理Son中的異常。
        //多型就不能實現了。
            try {
                 obj.start();
            }catch(IOException)
            {
                 //處理IOException
            }
         }
   }
}

==Java的異常執行流程是執行緒獨立的，執行緒之間沒有影響==

Java程式可以是多執行緒的。每一個執行緒都是一個獨立的執行流，獨立的函式呼叫棧。如果程式只有一個執行緒，那麼沒有被任何程式碼處理的異常會導致程式終止。如果是多執行緒的，那麼沒有被任何程式碼處理的異常僅僅會導致異常所在的執行緒結束。

也就是說，Java中的異常是執行緒獨立的，執行緒的問題應該由執行緒自己來解決，而不要委託到外部，也不會直接影響到其它執行緒的執行。

下面看一個例子

public class 多執行緒的異常 {
    @Test
    public void test() {
        go();
    }
    public void go () {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        for (int i = 0;i <= 2;i ++) {
            int finalI = i;
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            executorService.execute(new Runnable() {
                @Override
                //每個執行緒丟擲異常時並不會影響其他執行緒的繼續執行
                public void run() {
                    try {
                        System.out.println("start thread" + finalI);
                        throw new Exception();
                    }catch (Exception e) {
                        System.out.println("thread" + finalI + " go wrong");
                    }
                }
            });
        }
//        結果：
//        start thread0
//        thread0 go wrong
//        start thread1
//        thread1 go wrong
//        start thread2
//        thread2 go wrong
    }
}

當finally遇上return

首先一個不容易理解的事實：

在 try塊中即便有return，break，continue等改變執行流的語句，finally也會執行。

public static void main(String[] args)
{
    int re = bar();
    System.out.println(re);
}
private static int bar() 
{
    try{
        return 5;
    } finally{
        System.out.println("finally");
    }
}
/*輸出：
finally
*/

很多人面對這個問題時，總是在歸納執行的順序和規律，不過我覺得還是很難理解。我自己總結了一個方法。用如下GIF圖說明。

[外鏈圖片轉存失敗(img-SceF4t85-1569073569354)(http://incdn1.b0.upaiyun.com/2017/09/0471c2805ebd5a463211ced478eaf7f8.gif)]

也就是說：try…catch…finally中的return 只要能執行，就都執行了，他們共同向同一個記憶體地址（假設地址是0×80）寫入返回值，後執行的將覆蓋先執行的資料，而真正被呼叫者取的返回值就是最後一次寫入的。那麼，按照這個思想，下面的這個例子也就不難理解了。

finally中的return 會覆蓋 try 或者catch中的返回值。

public static void main(String[] args)
    {
        int result;
 
        result  =  foo();
        System.out.println(result);     /////////2
 
        result = bar();
        System.out.println(result);    /////////2
    }
 
    @SuppressWarnings("finally")
    public static int foo()
    {
        trz{
            int a = 5 / 0;
        } catch (Exception e){
            return 1;
        } finally{
            return 2;
        }
 
    }
 
    @SuppressWarnings("finally")
    public static int bar()
    {
        try {
            return 1;
        }finally {
            return 2;
        }
    }

finally中的return會抑制（消滅）前面try或者catch塊中的異常

class TestException
{
    public static void main(String[] args)
    {
        int result;
        try{
            result = foo();
            System.out.println(result);           //輸出100
        } catch (Exception e){
            System.out.println(e.getMessage());    //沒有捕獲到異常
        }
 
        try{
            result  = bar();
            System.out.println(result);           //輸出100
        } catch (Exception e){
            System.out.println(e.getMessage());    //沒有捕獲到異常
        }
    }
 
    //catch中的異常被抑制
    @SuppressWarnings("finally")
    public static int foo() throws Exception
    {
        try {
            int a = 5/0;
            return 1;
        }catch(ArithmeticException amExp) {
            throw new Exception("我將被忽略，因為下面的finally中使用了return");
        }finally {
            return 100;
        }
    }
 
    //try中的異常被抑制
    @SuppressWarnings("finally")
    public static int bar() throws Exception
    {
        try {
            int a = 5/0;
            return 1;
        }finally {
            return 100;
        }
    }
}

finally中的異常會覆蓋（消滅）前面try或者catch中的異常

class TestException
{
    public static void main(String[] args)
    {
        int result;
        try{
            result = foo();
        } catch (Exception e){
            System.out.println(e.getMessage());    //輸出：我是finaly中的Exception
        }
 
        try{
            result  = bar();
        } catch (Exception e){
            System.out.println(e.getMessage());    //輸出：我是finaly中的Exception
        }
    }
 
    //catch中的異常被抑制
    @SuppressWarnings("finally")
    public static int foo() throws Exception
    {
        try {
            int a = 5/0;
            return 1;
        }catch(ArithmeticException amExp) {
            throw new Exception("我將被忽略，因為下面的finally中丟擲了新的異常");
        }finally {
            throw new Exception("我是finaly中的Exception");
        }
    }
 
    //try中的異常被抑制
    @SuppressWarnings("finally")
    public static int bar() throws Exception
    {
        try {
            int a = 5/0;
            return 1;
        }finally {
            throw new Exception("我是finaly中的Exception");
        }
 
    }
}

上面的3個例子都異於常人的編碼思維，因此我建議：

不要在fianlly中使用return。

不要在finally中丟擲異常。

減輕finally的任務，不要在finally中做一些其它的事情，finally塊僅僅用來釋放資源是最合適的。

將盡量將所有的return寫在函式的最後面，而不是try … catch … finally中。

JAVA異常常見面試題

　　下面是我個人總結的在Java和J2EE開發者在面試中經常被問到的有關Exception和Error的知識。在分享我的回答的時候，我也給這些問題作了快速修訂，並且提供原始碼以便深入理解。我總結了各種難度的問題，適合新手碼農和高階Java碼農。如果你遇到了我列表中沒有的問題，並且這個問題非常好，請在下面評論中分享出來。你也可以在評論中分享你面試時答錯的情況。

1) Java中什麼是Exception?
　　這個問題經常在第一次問有關異常的時候或者是面試菜鳥的時候問。我從來沒見過面高階或者資深工程師的時候有人問這玩意，但是對於菜鳥，是很願意問這個的。簡單來說，異常是Java傳達給你的系統和程式錯誤的方式。在java中，異常功能是通過實現比如Throwable，Exception，RuntimeException之類的類，然後還有一些處理異常時候的關鍵字，比如throw，throws，try，catch，finally之類的。所有的異常都是通過Throwable衍生出來的。Throwable把錯誤進一步劃分為 java.lang.Exception
和 java.lang.Error. java.lang.Error 用來處理系統錯誤，例如java.lang.StackOverFlowError 之類的。然後 Exception用來處理程式錯誤，請求的資源不可用等等。

2) Java中的檢查型異常和非檢查型異常有什麼區別？

　　這又是一個非常流行的Java異常面試題，會出現在各種層次的Java面試中。檢查型異常和非檢查型異常的主要區別在於其處理方式。檢查型異常需要使用try, catch和finally關鍵字在編譯期進行處理，否則會出現編譯器會報錯。對於非檢查型異常則不需要這樣做。Java中所有繼承自java.lang.Exception類的異常都是檢查型異常，所有繼承自RuntimeException的異常都被稱為非檢查型異常。

3) Java中的NullPointerException和ArrayIndexOutOfBoundException之間有什麼相同之處？

　　在Java異常面試中這並不是一個很流行的問題，但會出現在不同層次的初學者面試中，用來測試應聘者對檢查型異常和非檢查型異常的概念是否熟悉。順便說一下，該題的答案是，這兩個異常都是非檢查型異常，都繼承自RuntimeException。該問題可能會引出另一個問題，即Java和C的陣列有什麼不同之處，因為C裡面的陣列是沒有大小限制的，絕對不會丟擲ArrayIndexOutOfBoundException。

4)在Java異常處理的過程中，你遵循的那些最好的實踐是什麼？

　　這個問題在面試技術經理是非常常見的一個問題。因為異常處理在專案設計中是非常關鍵的，所以精通異常處理是十分必要的。異常處理有很多最佳實踐，下面列舉集中，它們提高你程式碼的健壯性和靈活性：

　　1) 呼叫方法的時候返回布林值來代替返回null，這樣可以 NullPointerException。由於空指標是java異常裡最噁心的異常

　　2) catch塊裡別不寫程式碼。空catch塊是異常處理裡的錯誤事件，因為它只是捕獲了異常，卻沒有任何處理或者提示。通常你起碼要打印出異常資訊，當然你最好根據需求對異常資訊進行處理。

　　3)能拋受控異常（checked Exception）就儘量不拋受非控異常(checked Exception)。通過去掉重複的異常處理程式碼，可以提高程式碼的可讀性。

　　4) 絕對不要讓你的資料庫相關異常顯示到客戶端。由於絕大多數資料庫和SQLException異常都是受控異常，在Java中，你應該在DAO層把異常資訊處理，然後返回處理過的能讓使用者看懂並根據異常提示資訊改正操作的異常資訊。

　　5) 在Java中，一定要在資料庫連線，資料庫查詢，流處理後，在finally塊中呼叫close()方法。

5) 既然我們可以用RuntimeException來處理錯誤，那麼你認為為什麼Java中還存在檢查型異常?

　　這是一個有爭議的問題，在回答該問題時你應當小心。雖然他們肯定願意聽到你的觀點，但其實他們最感興趣的還是有說服力的理由。我認為其中一個理由是，存在檢查型異常是一個設計上的決定，受到了諸如C++等比Java更早程式語言設計經驗的影響。絕大多數檢查型異常位於java.io包內，這是合乎情理的，因為在你請求了不存在的系統資源的時候，一段強壯的程式必須能夠優雅的處理這種情況。通過把IOException宣告為檢查型異常，Java 確保了你能夠優雅的對異常進行處理。另一個可能的理由是，可以使用catch或finally來確保數量受限的系統資源（比如檔案描述符）在你使用後儘早得到釋放。 Joshua
Bloch編寫的 Effective Java 一書中多處涉及到了該話題，值得一讀。

6) throw 和 throws這兩個關鍵字在java中有什麼不同?

　　一個java初學者應該掌握的面試問題。 throw 和 throws乍看起來是很相似的尤其是在你還是一個java初學者的時候。儘管他們看起來相似，都是在處理異常時候使用到的。但在程式碼裡的使用方法和用到的地方是不同的。throws總是出現在一個函式頭中，用來標明該成員函式可能丟擲的各種異常, 你也可以申明未檢查的異常，但這不是編譯器強制的。如果方法丟擲了異常那麼呼叫這個方法的時候就需要將這個異常處理。另一個關鍵字 throw 是用來丟擲任意異常的，按照語法你可以丟擲任意 Throwable (i.e. Throwable
或任何Throwable的衍生類) , throw可以中斷程式執行，因此可以用來代替return . 最常見的例子是用 throw 在一個空方法中需要return的地方丟擲 UnSupportedOperationException 程式碼如下 :

123	private``static `void` show() {``throw``new UnsupportedOperationException(``"Notyet implemented"``);``}

　　可以看下這篇文章檢視這兩個關鍵字在java中更多的差異。

7) 什麼是“異常鏈”?

　　“異常鏈”是Java中非常流行的異常處理概念，是指在進行一個異常處理時丟擲了另外一個異常，由此產生了一個異常鏈條。該技術大多用於將“ 受檢查異常” （ checked exception）封裝成為“非受檢查異常”（unchecked exception)或者RuntimeException。順便說一下，如果因為因為異常你決定丟擲一個新的異常，你一定要包含原有的異常，這樣，處理程式才可以通過getCause()和initCause()方法來訪問異常最終的根源。

) 你曾經自定義實現過異常嗎？怎麼寫的?

　　很顯然，我們絕大多數都寫過自定義或者業務異常，像AccountNotFoundException。在面試過程中詢問這個Java異常問題的主要原因是去發現你如何使用這個特性的。這可以更準確和精緻的去處理異常，當然這也跟你選擇checked 還是unchecked exception息息相關。通過為每一個特定的情況建立一個特定的異常，你就為呼叫者更好的處理異常提供了更好的選擇。相比通用異常（general exception)，我更傾向更為精確的異常。大量的建立自定義異常會增加專案class的個數，因此，在自定義異常和通用異常之間維持一個平衡是成功的關鍵。

9) JDK7中對異常處理做了什麼改變？

　　這是最近新出的Java異常處理的面試題。JDK7中對錯誤(Error)和異常(Exception)處理主要新增加了2個特性，一是在一個catch塊中可以出來多個異常，就像原來用多個catch塊一樣。另一個是自動化資源管理(ARM), 也稱為try-with-resource塊。這2個特性都可以在處理異常時減少程式碼量，同時提高程式碼的可讀性。對於這些特性瞭解，不僅幫助開發者寫出更好的異常處理的程式碼，也讓你在面試中顯的更突出。我推薦大家讀一下Java 7攻略，這樣可以更深入的瞭解這2個非常有用的特性。

10) 你遇到過 OutOfMemoryError 錯誤嘛？你是怎麼搞定的？

　　這個面試題會在面試高階程式設計師的時候用，面試官想知道你是怎麼處理這個危險的OutOfMemoryError錯誤的。必須承認的是，不管你做什麼專案，你都會碰到這個問題。所以你要是說沒遇到過，面試官肯定不會買賬。要是你對這個問題不熟悉，甚至就是沒碰到過，而你又有3、4年的Java經驗了，那麼準備好處理這個問題吧。在回答這個問題的同時，你也可以藉機向面試秀一下你處理記憶體洩露、調優和除錯方面的牛逼技能。我發現掌握這些技術的人都能給面試官留下深刻的印象。

11) 如果執行finally程式碼塊之前方法返回了結果，或者JVM退出了，finally塊中的程式碼還會執行嗎？

　　這個問題也可以換個方式問：“如果在try或者finally的程式碼塊中呼叫了System.exit()，結果會是怎樣”。瞭解finally塊是怎麼執行的，即使是try裡面已經使用了return返回結果的情況，對了解Java的異常處理都非常有價值。只有在try裡面是有System.exit(0)來退出JVM的情況下finally塊中的程式碼才不會執行。

12)Java中final,finalize,finally關鍵字的區別

　　這是一個經典的Java面試題了。我的一個朋友為Morgan Stanley招電信方面的核心Java開發人員的時候就問過這個問題。final和finally是Java的關鍵字，而finalize則是方法。final關鍵字在建立不可變的類的時候非常有用，只是宣告這個類是final的。而finalize()方法則是垃圾回收器在回收一個物件前呼叫，但也Java規範裡面沒有保證這個方法一定會被呼叫。finally關鍵字是唯一一個和這篇文章討論到的異常處理相關的關鍵字。在你的產品程式碼中，在關閉連線和資原始檔的是時候都必須要用到finally塊。

參考文章

https://www.xuebuyuan.com/3248044.html
https://www.jianshu.com/p/49d2c3975c56
http://c.biancheng.net/view/1038.html
https://blog.csdn.net/Lisiluan/article/details/88745820
https://blog.csdn.net/michaelgo/article/details/82790253

微信公眾號

Java技術江湖

如果大家想要實時關注我更新的文章以及分享的乾貨的話，可以關注我的公眾號【Java技術江湖】一位阿里 Java 工程師的技術小站，作者黃小斜，專注 Java 相關技術：SSM、SpringBoot、MySQL、分散式、中介軟體、叢集、Linux、網路、多執行緒，偶爾講點Docker、ELK，同時也分享技術乾貨和學習經驗，致力於Java全棧開發！

Java工程師必備學習資源: 一些Java工程師常用學習資源，關注公眾號後，後臺回覆關鍵字 “Java” 即可免費無套路獲取。

個人公眾號：黃小斜

作者是 985 碩士，螞蟻金服 JAVA 工程師，專注於 JAVA 後端技術棧：SpringBoot、MySQL、分散式、中介軟體、微服務，同時也懂點投資理財，偶爾講點演算法和計算機理論基礎，堅持學習和寫作，相信終身學習的力量！

程式設計師3T技術學習資源：一些程式設計師學習技術的資源大禮包，關注公眾號後，後臺回覆關鍵字 “資料” 即可免費無套路獲取。

夯實Java基礎系列10：深入理解Java中的異常體系

目錄