「JAVA」詳述Java異常體系，處理異常時配上finally效果更佳

時間 2020-07-06

標籤 java 詳述異常體系處理配上 finally 效果更佳欄目 Java 简体版

原文原文鏈接

什麼是異常

從事Java開發的小夥伴對於「異常」應該不陌生，由於天天都會遇到很多異常，或捕獲，或拋出。那究竟什麼是異常？異常即非正常的，不一樣於日常、通常化的狀況。在平時生活中，醫生會說你身體的某個部位有異常，該異常會有什麼什麼的影響，是由某某緣由引發的；我天天都準時打卡，按時上下班，那麼我本月的考勤是正常的，反之，但凡是有遲到、曠工、早退的狀況之一的，我本月的考情就會有異常。java

而在程序中，代碼在運行中若是出現運行錯誤，程序會終止運行，這時因爲錯誤致使程序運行終止的狀況就是程序出現了異常。異常並非指語法錯誤，由於若是語法錯了，編譯就通不過，不會產生JVM可以識別的字節碼文件，是無法運行起來的，因此只有運行中的程序纔會有異常一說。程序員

Java 異常體系

異常處理是衡量一門語言是否成熟的標準之一，C系列的語言諸如：Java、C++、C 等都支持異常處理，有本身的一套異常處理機制。異常處理機制可讓程序有更好的容錯性，使代碼更加健壯；但C語言卻沒有異常處理機制，C程序員通常都是利用方法的返回值來實現異常處理，使用 if + 條件 來判斷正常和異常狀況，使用特定返回值來表示異常狀況。數據庫

引入異常處理機制能夠解決的問題有：數組

使用方法的返回值來表示異常狀況有侷限性，須要無窮列舉全部的異常狀況；
異常流程代碼和正常流程代碼混合一塊兒，代碼每每很臃腫，也很複雜性；代碼的可讀性和可維護性都不高；
隨着系統規模的不斷擴大，代碼很難維護，特別是系統可拓展性差；

經過一下這個案例來講明引入異常以前的處理方式：網絡

// 汽車
class Car {    
    // 汽車是否正常運行    
    public static final boolean IS_OK = true;    

    // 汽車運行    
    public boolean run(int wheelNum) {        
        if (wheelNum == 4) {           
            return true;        
        }        
        return false;     
    }
}

// 上班族
class Officer {    
    private Car car;    
    public Officer(Car car) {       
         this.car = car;    
    }    
    
    // 開車去上班    
    public boolean goWorkByCar(int wheelNum) {       
           if (car == null) {            
                  // 只能選擇其餘出行方式了            
                  goWorkByOther();            
                  return false;        
            }        
            boolean result = car.run(wheelNum);        
            if (result) {            
                 System.out.println("升職，加薪，迎娶白富美");            
                 return true;        
            }        
            System.out.println("遲到，扣薪，領導每天噴");        
            return false;    
      }    
      // 其餘方式上班    
      public void goWorkByOther() {        
            System.out.println("其餘方式上班");    
      }
}
      
// 運行demo
public class WorkDemo {    
      public static void main(String[] args) {        
              Car car = new Car();        
              Officer officer = new Officer(car);        
              officer.goWorkByCar(4);    
      }
}

上述案例中，只是簡單粗暴的把汽車的狀態分爲true和false兩種，細化不夠，不能體現出汽車的詳細狀態；業務邏輯也很侷限，若是要拓展，就要花費更大的成本。ide

針對於上述的問題，Java基於面向對象的思想提出瞭解決方案：性能

把不一樣類型的異常狀況使用不一樣的類來表示，不一樣的異常類有共同的父類；
分離異常流程代碼和正確流程代碼；
規範了異常處理機制，靈活處理異常，能處理就將其捕獲並處理，若是處理不了異常，就將其交給調用者來處理；

Java 異常體系：Java API文檔中的詳細介紹以下this

Error：表示錯誤，通常指JVM相關的不可修復的錯誤，如：系統崩潰、內存溢出、JVM內部錯誤等，由JVM拋出，咱們通常狀況下不須要處理，幾乎其全部的子類都是以「Error」做爲類名後綴；好比：StackOverflowError，當應用程序遞歸太深而發生內存溢出時，就會拋出該錯誤。
Exception：表示異常，指程序中出現不正常的狀況，異常通常都是須要程序員來處理的（能夠捕獲或者拋出）；幾乎其全部的子類都是以「Exception」做爲類名的後綴；
Throwable：在Java 體系中，Throwable類是全部錯誤和異常的父類；

當出現了沒見過的異常時，能夠將異常類的類名拿到Java API文檔中去查找，經過文章介紹便可得到異常的詳細信息，以及其在Java中的繼承、實現體系；常見的Exception有：spa

NullPointerException：空指針異常，通常當對象爲null的時候，對該對象作操做時會出現該異常；
ArrayIndexOutOfBoundsException：數組的索引越界，操做數組時使用的索引超出了數組的數據範圍會出現；
NumberFormatException：數字格式化異常，把非數字的數據類型轉換爲數字類型時使用了非法的轉換對象；

Java 的異常詳解：3d

public class ExceptionDemo {    
     public static void main(String[] args) {        
        Integer.valueOf("laofu");    
     }
}

運行結果以下：

若是出現異常，會馬上中斷運行中的程序，因此必須處理異常，而處理方式有兩種：

throws：當前方法不處理，而是聲明拋出，由該方法的調用者來處理；
try-catch：在當前方法中使用try-catch的語句塊來處理異常；

捕獲異常 try-catch

出現異常以後，程序會中斷執行，因此異常必須處理；處理的方式有兩種：捕獲和拋出，兩種方式二選一便可。咱們先來運行一個案例來證實：

public static void main(String[] args) {        
    System.out.println("老夫開始啦");        
    int result = 10 / 2;        
    System.out.println("10 / 2 = " + result);        
    System.out.println("老夫去也");
}

運行結果以下：

老夫開始啦
10 / 2 = 5
老夫去也

經過查看運行結果，是咱們指望的運行結果，代碼運行成功；那麼接下來咱們對上述案例稍做修改，再來看其運行結果如何：

public static void main(String[] args) {        
    System.out.println("老夫開始啦");        
    int result = 10 / 0;        
    System.out.println("10 / 2 = " + result);        
    System.out.println("老夫去也");   
 }

運行結果以下：

老夫開始啦
Exception in thread "main" java.lang.ArithmeticException: / by zero    
            at Main.main(Main.java:5)

經過查看運行結果，運行結果並非咱們想要的，代碼中出現了異常，代碼被中斷運行。對比兩次的運行結果，咱們能夠得出結論：出現異常以後，程序會中斷執行，異常必須處理。

try-catch 異常捕獲：使用try-catch捕獲單個異常，語法以下：

try{     
    編寫可能會出現異常的代碼
} catch(異常類型  e) {     
    處理異常的代碼     
    //記錄日誌/打印異常信息/繼續拋出異常
}

注意：try和catch都不能單獨使用，必須連用

因此能夠對上述出現異常的代碼使用try-catch來處理：

public class ExceptionDemo {    
    public static void main(String[] args) {        
        System.out.println("老夫開始啦");        
        try {          
            int result = 10 / 0;          
            System.out.println("10 / 2 = " + result);        
        } catch (ArithmeticException e) {          
            System.out.println("異常信息：" + e.getMessage()); 
            System.out.println("異常對象：" + e.toString());  
            System.out.println("異常棧追蹤：");          
            e.printStackTrace();        
        }        
        System.out.println("老夫去也");        
    }
}

運行結果以下：

老夫開始啦異常信息：/ by zero
異常對象：java.lang.ArithmeticException: / by zero
異常棧追蹤：老夫去也java.lang.ArithmeticException: / by zero    
                  at Main.main(Main.java:6)

經過查看運行結果，不難發現，使用try-catch以後，程序遇到異常時再也不中斷執行，而是跳過異常代碼及其以後的在try-catch中的剩餘代碼語句，來到catch代碼塊中執行咱們定義的異常處理代碼；

在上述案例中是打印出了異常信息，異常對象信息，異常棧追蹤；其中的3個方法都是Throwable類的方法：

String getMessage()：獲取異常的詳細描述信息；
String toString()：獲取異常的類型、異常描述信息；
void printStackTrace()：打印異常的跟蹤棧信息並輸出到控制檯，但不能在System.out.println()中使用該方法；其中包含了異常的類型、異常的緣由、異常出現的位置；在開發和調試階段，該方法都頗有用，方便調試和修改；

使用try-catch捕獲多個異常：語法以下：

try{     
    編寫可能會出現異常的代碼
} catch (異常類型A  e){  // 當try中出現A類型異常,就用該catch來捕獲.
    處理異常的代碼    
    //記錄日誌/打印異常信息/繼續拋出異常
} catch (異常類型B  e){  // 當try中出現B類型異常,就用該catch來捕獲.    
   處理異常的代碼     
    //記錄日誌/打印異常信息/繼續拋出異常
}

注意

一個catch語句，只能捕獲一種類型的異常，若是須要捕獲多種異常類型，就得使用多個catch語句；
try-catch中的代碼在只會出現一種類型的異常，只能一個catch捕獲，不可能同時匹配多個catch；
在有多個catch語句的代碼中出現異常時，會從上到下依次匹配catch語句，因此多個catch語句應該按照從子類到父類的順序依次定義；
一旦匹配上其中一個catch以後，便不會匹配剩餘的catch，而是會跳出try-catch，執行以後的代碼；

捕獲多個異常的案例：

運行結果以下：

老夫開始啦
NumberFormatException
老夫去也
java.lang.NumberFormatException: For input string: "laofu"    
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)    
at java.lang.Integer.parseInt(Integer.java:580)    
at java.lang.Integer.parseInt(Integer.java:615)    
at Main.main(Main.java:7)

拋出異常

拋出異常有兩種方式：

throw：用於方法內部，用於給調用者返回一個異常對象，和return同樣會結束當前方法；
throws：運用於方法聲明之上，定義於方法參數以後，表示當前方法不處理異常，而是提醒該方法的調用者來處理拋出的異常(一個或者多個異常)；如：private static int divide(int num1, int num2) throws Exception {}

throw語句：運用於方法內部，拋出一個具體的異常對象，停止方法的執行，其語法格式以下：

throw  new  異常類("異常信息");

通常的，當一個方法出現異常的狀況，咱們不知道該方法應該返回什麼時，此時就能夠返回一個錯誤，在catch語句塊中使用throw繼續向上拋出異常。return 是返回一個值，throw是返回一個錯誤，返回給該方法的調用者。好比：String類的charAt方法就是一個很好的例子：

throws：

若是每個方法都放棄處理異常都直接經過throws聲明拋出，最後異常會拋到main方法，若是此時main方法還不處理，會繼續拋出給JVM，JVM底層的處理機制就是打印異常的跟蹤棧信息；runtime異常，默認就是這種處理方式。

方法重寫(Override)中的throws：

一同：方法的簽名必須相同。

兩小：

子類方法返回類型和父類方法返回類型相同，或是其子類；
子類方法不能聲明拋出新的異常；

一大：子類方法的訪問權限必須大於等於父類方法的訪問權限。

異常分類

異常(Exception)根據其在編譯時期仍是運行時期去檢查異常可分爲：checked異常和runtime異常，

runtime異常：又稱運行時期異常，此類型的異常在運行時期檢查；在編譯時期，運行異常並不會檢測，就不會出現，只有在運行到相關代碼時纔會出現；RuntimeException自身及其子類異常都屬於runtime異常；
checked異常：又稱編譯時期異常，此類型的異常在編譯時期就會檢查，並且是必須處理的，若是沒有處理，就會致使編譯失敗；除了runtime異常以外的其餘異常（包括Exception自身）都屬於checked異常；