摘要：異常處理機制異常與異常類的繼承體系在程序中，當程序出現意外情況時，系統會自動生成一個來通知程序，從異常發生出逐漸向外傳播，如果沒有人來處理該異常，就會交給來處理，對異常的處理方法是，打印異常跟蹤棧信息，并中止程序的執行。

1 為什么要處理異常？

異常機制可以使程序的異常處理代碼與正常業務代碼分離，保證程序代碼的健壯性。
在設計程序的時候，好的程序需要盡可能處理已知的可能產生的錯誤，但是事實上并不可能考慮到所有可能產生異常的情況，同時，眾多的類似if-else的錯誤處理代碼可能會帶來很多的代碼冗雜，錯誤處理與業務代碼混雜的情況，帶來閱讀和維護的難度。因此我們需要合適的異常處理機制。
java的異常機制依靠于try,catch,finally,throw,throws關鍵字，其中try塊中通常放置可能引發異常的代碼，catch后對應異常類型和響應的異常處理代碼塊，finally塊在java異常機制中總是會被執行，通常用于回收try塊中打開的物理資源，throw用于拋出一個實際的異常（異常的實例），throws主要在方法簽名中使用，用于聲明該方法可能會拋出的異常，方便或者提醒方法的使用者來捕獲并處理異常。
2 異常處理機制

2.1 異常與異常類的繼承體系

在java程序中，當程序出現意外情況時，系統會自動生成一個Exception來通知程序，從異常發生出逐漸向外傳播，如果沒有人來處理該異常，就會交給jvm來處理，jvm對異常的處理方法是，打印異常跟蹤棧信息，并中止程序的執行。
java提供了豐富的異常類體系，所有的異常類都繼承自Throwable父類

java異常處理體系.jpg
注意：
Error錯誤：一般與虛擬機相關，如系統崩潰，動態鏈接錯誤等，這種錯誤無法恢復也無法捕獲，所以應用程序一般不能處理這些錯誤，也不應該試圖去捕獲這類對象
我們主要處理的Exception類，該類在java中分為兩類，一種是Checked異常，一種是Runtime異常。Checked異常是java特有的，在java設計哲學中，Checked異常被認為是可以被處理或者修復的異常，所以java程序必須顯式處理Checked異常，當我們使用或者出現Checked異常類的時候，程序中要么顯式try- catch捕獲該異常并修復，要么顯式聲明拋出該異常，否則程序無法通過編譯。（Checked異常某種程度上降低了開發生產率和代碼執行率，在java領域是一個備受爭論的問題）
常見的運行時異常：如上圖所示，這里列舉幾個比較常見的。

public class test{
    public static void main(String[] args){
        try{
            int a = Integer.parseInt(args[0]);
            int b = Integer.parseInt(args[1));
            int c = a/b;
            System.out.println("您輸出的結果是"+c);
        }
        catch(IndexOutOfBoundsException ie){
            System.out.println("數組越界，輸入的參數不夠")；
        }
        catch(NumberFormatException ne){
            System.out.println("數字格式異常：程序只能接收整數參數")；
        }
        catch(ArithmeticException ae){
            System.out.println("算術法異常")；
        }
        catch(Exception e){
            System.out.println("出現異常")；
        }
        
        Date d = null;
        try{
            System.out.println(d.after(new Date()));
        }
        // 試圖調用一個null對象的方法或者實例變量時 出現的異常
        catch(NullPointerException ne){
            System.out.println("指向異常")；
        }
    }
}

程序中一般將Exception放在最后，先捕獲小異常（子類異常），再捕獲大異常。如果順序顛倒，還會出現編譯錯誤。
2.2 try ... catch異常捕獲

try ... catch 是最常見的異常捕獲語句，try后與{ }配對使用，其中是業務實現代碼，如果try塊中出現問題或者異常，系統自動生成一個異常對象，該異常對象提交到Java運行環境，java運行環境收到異常對象后，會尋找能夠處理該異常的catch塊，如果找到，就將異常對象交給該catch塊處理，如果沒有找到，就終止程序運行。

從異常捕獲過程中，我們可以看到程序要慎重考慮可能出現異常的代碼塊，否則這段程序是不夠健壯的，一個經常出現崩潰或被終止的程序，是災難性的。

catch塊中如何處理異常：

一個try塊之后可能存在多個catch塊，java運行時與catch塊（）內的異常類進行比較，判斷該異常是否 instanceof 該類，如果屬于該類，就將該異常對象傳給catch塊內的異常形參，catch塊后可以對該異常進行處理，獲取相關異常的詳細信息等。注意系統生成的異常實例對象是相對具體的子類異常對象，而進入一個catch塊后就不會再進入下一個catch塊，所以這也是我們盡量將小異常放在大異常前面的原因。
常見操作：輸出出現異常提示信息
訪問異常信息，打印異常信息

getMessage();// 返回詳細描述字符串 
printStackTrace();// 打印異常跟蹤棧信息到標準錯誤窗口
printStackTrace(PrintStream s);// 跟蹤棧信息輸出到指定輸出流
getStackTrace();// 返回跟蹤棧信息

采用別的替選數據或方案，或者提示用戶重新操作，或者重新拋出異常，進行異常轉譯，重新包裝，交給上層調用者來對該異常進行處理。
多異常捕獲：（java 7 提供的新特性）

public class test{
    public static void main(String[] args){
        try{
            int a = Integer.parseInt(args[0]);
            int b = Integer.parseInt(args[1));
            int c = a/b;
            System.out.println("您輸出的結果是"+c);
        }
        catch(IndexOutOfBoundsException ie | NumberFormatException ne
             |ArithmeticException ae){
            System.out.println("程序發生上述異常的某一種")；
            // 此時ie ，ne， ae都是默認 final修飾的變量 不能再重新賦值
        }
        catch(Exception e){
            System.out.println("出現異常");
            // 此時可以賦值
            e = new RuntimeException("new error")；
        }
        
    }
}

2.3 finally 一定會執行的finally模塊

通常try塊里打開了一些物理資源，（比如磁盤文件，數據庫連接等），這些需要保證回收，所以我們通常在finally塊中進行回收。
舉個例子

public class test{
    public static void main(String[] args){
        FileInputStream fis = null;
        try{
            fis = new FileInputStream("a.txt");
        }
        catch(IOException e){
            System.out.println(e.getMessage);
            
            //如果執行return,程序會先跳到finally塊執行，執行完之后再回來執行return語句
            return;
            // 如果這里是System.exit(0),因為是退出虛擬機
            // 所以finally塊沒辦法執行
        }
        finally{
            if(fis!= null){
                try{
                    fis.close();
                }
                catch(IOException e){
                    e.printStackTrace();
                }
            }
        }
    }
}

注意：盡量不要在finally塊中使用return或者throw語句，因為一旦在finally中執行，程序就不會再跳回原來try或者catch塊中執行原本應該執行的return和throw語句了，程序自己就結束了，這可能會帶來一些麻煩的錯誤。
為了方便物理資源的關閉，java7 提供了一種新的語法，增強了try的功能，可以在try后面跟一對圓括號，來聲明初始化物理資源，try執行完畢后會自動關閉資源。

public class AutoClose{
    public static void main(String[] args)
    throws IOException
    {
        // ()內的資源類必須實現AutoCloseable 或者Closeable接口中的close()方法
        try(BufferedReader br  = new BufferedReader(
        new FileReader("auto.java")))
        {
            System.out.println(br.readLine());
        }
        
    }
}

2.4 throws 關鍵字：聲明拋出異常

throws聲明拋出異常，在方法簽名中使用，上面的AtuoClose就是其使用的例子。它可以聲明拋出多個類，多個類之間用“，”隔開。

首先要理解我們為什么要聲明拋出異常：當某個方法中程序的執行可能會出現異常，但是該方法并不知道如何處理異常，或者我們想把這個異常交給上層方法調用者來處理或者修復，那我們給該方法加上關鍵字throws 異常，以聲明該方法可能會出現的異常。自然，加了throws關鍵字之后，該方法我們就無需再用try—catch來捕獲異常了，因為這已經不是我們這個方法需要操心的事情了。

注意使用throws聲明異常的時候，涉及到子類對父類的方法重寫時，子類聲明的異常類型應該是父類方法聲明的異常類型的子類或者相同類。

如果throws 聲明的是checked異常，根據checked異常的規定，我們不能對該異常視而不見，因為我們必須處理該異常，所以當拿到一個聲明了可能會發生checked異常的方法時，在調用該方法時，要么放在try塊中來顯式捕捉該異常，要么放在另外一個帶throws聲明異常的方法中。
所以使用checked異常時，要特別注意處理它的問題，還會帶來方法重寫的限制性，因此大部分時候推薦使用Runtime異常。

public class ThrowTest{
    public static void main(String[] args)
    throws Exception
    {
        test();//test 聲明會產生checked 異常 因此main函數也需要聲明異常
        // 或者在try - catch 中捕獲該異常
    }
    
    public void test() throws IOException{
        FileInputStream fis = new FileInputStream("a.text");
    }

}

2.5 throw關鍵字 ：拋出異常

java允許程序自行拋出異常，通常系統幫助我們檢查是否發生一些普遍定義的異常，但是有些異常可能不是普遍定義的，只是與我們業務不符，所以我們可以自行拋出異常，也可以自行拋出一些我們自定義的異常，而拋出異常的行為與系統拋出異常的行為一定程度上是等價的，后續處理方式也是一樣的，在這里我們使用throw關鍵字。

throw語句可以多帶帶使用，注意它拋出的是一個異常實例。

try{
    // do something...
    throw new Exception("hhh 我是新異常");  // 異常實例
}
catch{
    System.out.println("出現異常")；
    continue;
}

當我們自行拋出的異常是checked異常的時候，該throw語句要么是在如上面例子中的try塊中，顯示捕獲，要么是在一個已經用throws聲明會出現異常的方法中，而如果我們拋出的是runtime異常，那么情況就很簡單了，它無需在try塊中，也不需要將對應的方法用throws聲明，如果我們想要處理，就捕獲處理它，不管是在它自身方法體內，或者是對應方法者，也可以不去理會，當然我們自己拋出的異常，通常情況下是要處理的，不然拋出去之后不管最后只能中斷程序運行了，只不過拋出是runtime異常時，在編譯時沒有那么嚴格。

自定義異常類：前面說了，系統會拋出一些普遍意義的異常，那么我們也就沒必要再自己操心throw了，通常throw的是自定義的異常類。

自定義異常類都應該繼承Exception類，或者Exception下的子類如runtime異常
定義異常類的時候需要提供兩個構造器，一個無參構造器，一個帶一個字符串參數的構造器，這串字符串實際上是getMessage() 時返回的異常對象的詳細描述信息。

public class myException extends Exception{
    public myException(){};
    public myException(String msg){
        super(msg);
    }
}

catch中throw（拋出）異常：有時候我們在本方法中捕捉了異常，我們只能處理異常的一部分，我們還需要別的方法來處理或者我們想把產生了異常的這個信息告訴調用者，這個時候我們通常捕捉了異常后會在catch塊中拋出我們想拋出的異常
在企業級應用中，通常對異常處理分為兩部分：應用后臺打印或者通過日志記錄異常發生時詳細情況（異常跟蹤棧）和向使用者傳達某種提示。
java 7 中增強了throw語句：java 7 編譯器執行更細致檢查，檢查拋出的異常的具體類型。

public class Test{
    private double initprice = 30.0;
    // 自定義的異常 
    // 方法中拋出了異常 所以此處要聲明異常
    public void bid(String bidprice) throws AuctionException{
        double d =0.0;
        try{
            d = Double.parseDouble(bidprice);
        }
        catch(Exception e){
            e.printStackTrace();
            throw new AuctionException("新異常")；
            
            //這里也可以拋出e 但是我們通常會拋出我們包裝過后的異常
            // 用來向方法調用者或者上層提示某種信息 而不會直接暴露異常的原因
            // throw e; 
            // 如果這里throw e 在java7 以前不會做細致檢查，throws聲明那里必須聲明為Exception
            // 但是java7 之后可以聲明為更細致的異常子類型
            
        }
    }
    public static void main(String[] args){
        Test test = new Test();
        try{
            test.bid("df");
        }
        catch(AuctionException ae){
            System.err.println(ae.getMessage);
        }
    }
}

異常鏈：異常轉譯與異常鏈
3. 異常處理的一些基本規則

3.1 異常跟蹤棧

異常是從里向外傳播，可以很方便跟蹤異常的發生情況，可以用來調試程序，但在發布的程序中，應該避免使用，而是將異常進行適當的處理。
3.2 不要過度使用

異常的運行效率會差一些，因此如果不是那種不可預期的錯誤，應該避免使用異常，而是放在正常的業務判斷或者處理邏輯中。
3.3 不要使用過于龐大的try塊

為了更好的判斷發生的異常的類型，應該將大塊try塊分割為多個可能出現異常的try段落。
3.4 避免catch-all

類似上面的理由，更好的區分度，更好的異常判斷
3.5 不要忽略異常

避免catch塊為空，或者僅僅打印出異常情況，我們還是要處理異常，比如繞過異常發生的地方，或者采用別的替選數據或方案，或者提示用戶重新操作，或者重新拋出異常，進行異常轉譯，重新包裝，交給上層調用者來對該異常進行處理。

歡迎加入學習交流群569772982，大家一起學習交流。