今天動力節點Java培訓機構小編為大家介紹“JAVA中異常與異常處理詳解”，希望通過此文能夠幫助大家，下面就隨小編一起看看JAVA中異常與異常處理詳解。

Java異常簡介

程序運行時，發生的不被期望的事件，它阻止了程序按照程序員的預期正常執行，這就是異常。異常發生時，是任程序自生自滅，立刻退出終止，還是輸出錯誤給用戶?或者用C語言風格：用函數返回值作為執行狀態?。

　　Java提供了更加優秀的解決辦法：異常處理機制。

　　異常處理機制能讓程序在異常發生時，按照代碼的預先設定的異常處理邏輯，針對性地處理異常，讓程序盡最大可能恢復正常并繼續執行，且保持代碼的清晰。

　　Java中的異常可以是函數中的語句執行時引發的，也可以是程序員通過throw 語句手動拋出的，只要在Java程序中產生了異常，就會用一個對應類型的異常對象來封裝異常，JRE就會試圖尋找異常處理程序來處理異常。

　　Throwable類是Java異常類型的頂層父類，一個對象只有是 Throwable 類的(直接或者間接)實例，他才是一個異常對象，才能被異常處理機制識別。JDK中內建了一些常用的異常類，我們也可以自定義異常。

Java異常的分類和類結構圖

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

　　Throwable又派生出Error類和Exception類。

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

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

　　總體上我們根據Java c對異常的處理要求，將異常類分為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 等。

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

初識異常

下面的代碼會演示2個異常類型：ArithmeticException 和 InputMismatchException。前者由于整數除0引發，后者是輸入的數據不能被轉換為int類型引發。

package com.example;

import java. util .Scanner ;

public class AllDemo

{

      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 ;

      }

}

/*****************************************

----歡迎使用命令行除法計算器----

0

Exception in thread "main" java.lang.ArithmeticException : / by zero

     at com.example.AllDemo.devide( AllDemo.java:30 )

     at com.example.AllDemo.CMDCalculate( AllDemo.java:22 )

     at com.example.AllDemo.main( AllDemo.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.example.AllDemo.CMDCalculate( AllDemo.java:20 )

     at com.example.AllDemo.main( AllDemo.java:12 )

*****************************************/

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

　　異常最先發生的地方，叫做異常拋出點。

從上面的例子可以看出，當devide函數發生除0異常時，devide函數將拋出ArithmeticException異常，因此調用他的CMDCalculate函數也無法正常完成，因此也發送異常，而CMDCalculate的caller——main 因為CMDCalculate拋出異常，也發生了異常，這樣一直向調用棧的棧底回溯。這種行為叫做異常的冒泡，異常的冒泡是為了在當前發生異常的函數或者這個函數的caller中找到最近的異常處理程序。由于這個例子中沒有使用任何異常處理機制，因此異常最終由main函數拋給JRE，導致程序終止。

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

　　代碼中小編選擇使用throws聲明異常，讓函數的調用者去處理可能發生的異常。但是為什么只throws了IOException呢?因為FileNotFoundException是IOException的子類，在處理范圍內。

@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.clos

}

Java異常處理的基本語法

在編寫代碼處理異常時，對于檢查異常，有2種不同的處理方式：使用try...catch...finally語句塊處理它。或者，在函數簽名中使用throws 聲明交給函數調用者caller去解決。

　　try...catch...finally語句塊

　　try...catch...finally語句塊

try{

     //try塊中放可能發生異常的代碼。

     //如果執行完try且不發生異常，則接著去執行finally塊和finally后面的代碼（如果有的話）。

     //如果發生異常，則嘗試去匹配catch塊。

}catch(SQLException SQLexception){

    //每一個catch塊用于捕獲并處理一個特定的異常，或者這異常類型的子類。Java7中可以將多個異常聲明在一個catch中。

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

    //在catch塊中可以使用這個塊的異常參數來獲取異常的相關信息。異常參數是這個catch塊中的局部變量，其它塊不能訪問。

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

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

}catch(Exception exception){

    //...

}finally{

    //finally塊通常是可選的。

   //無論異常是否發生，異常是否匹配被處理，finally都會執行。

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

  //finally主要做一些清理工作，如流的關閉，數據庫連接的關閉等。 

}

注意：

　　1、try塊中的局部變量和catch塊中的局部變量(包括異常變量)，以及finally中的局部變量，他們之間不可共享使用。

　　2、每一個catch塊用于處理一個異常。異常匹配是按照catch塊的順序從上往下尋找的，只有第一個匹配的catch會得到執行。匹配時，不僅運行精確匹配，也支持父類匹配，因此，如果同一個try塊下的多個catch異常類型有父子關系，應該將子類異常放在前面，父類異常放在后面，這樣保證每個catch塊都有存在的意義。

　　3、java中，異常處理的任務就是將執行控制流從異常發生的地方轉移到能夠處理這種異常的地方去。也就是說：當一個函數的某條語句發生異常時，這條語句的后面的語句不會再執行，它失去了焦點。執行流跳轉到最近的匹配的異常處理catch代碼塊去執行，異常被處理完后，執行流會接著在“處理了這個異常的catch代碼塊”后面接著執行。

　　有的編程語言當異常被處理后，控制流會恢復到異常拋出點接著執行，這種策略叫做：resumption model of exception handling(恢復式異常處理模式 )

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

public static void main(String[] args){

        try {

            foo();

        }catch(ArithmeticException ae) {

            System.out.println("處理異常");

        }

}

public static void foo(){

        int a = 5/0;  //異常拋出點

        System.out.println("為什么還不給我漲工資!!!");  //////////////////////不會執行

}

　　throws 函數聲明

　　throws聲明：如果一個方法內部的代碼會拋出檢查異常(checked exception)，而方法自己又沒有完全處理掉，則javac保證你必須在方法的簽名上使用throws關鍵字聲明這些可能拋出的異常，否則編譯不通過。

　　throws是另一種處理異常的方式，它不同于try...catch...finally，throws僅僅是將函數中可能出現的異常向調用者聲明，而自己則不具體處理。

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

public void foo() throws ExceptionType1 , ExceptionType2 ,ExceptionTypeN

{ 

     //foo內部可以拋出 ExceptionType1 , ExceptionType2 ,ExceptionTypeN 類的異常，或者他們的子類的異常對象。

}

　　Java 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塊。

　　throw異常拋出語句

　　throw exceptionObject

　　程序員也可以通過throw語句手動顯式的拋出一個異常。throw語句的后面必須是一個異常對象。

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

public void save(User user)

{

      if(user  == null) 

          throw new IllegalArgumentException("User對象為空");

      //......

}

Java異常的鏈化

在一些大型的，模塊化的軟件開發中，一旦一個地方發生異常，則如骨牌效應一樣，將導致一連串的異常。假設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;

    }

    //........

}

下面是一個例子，演示了異常的鏈化：從命令行輸入2個int，將他們相加，輸出。輸入的數不是int，則導致getInputNumbers異常，從而導致add函數異常，則可以在add函數中拋出一個鏈化的異常。

public static void main(String[] args)

{

    System.out.println("請輸入2個加數");

    int result;

    try

    {

        result = add();

        System.out.println("結果:"+result);

    } catch (Exception e){

        e.printStackTrace();

    }

}

//獲取輸入的2個整數返回

private static ListgetInputNumbers()

{

    Listnums = new ArrayList<>();

    Scanner scan = new Scanner(System.in);

    try {

        int num1 = scan.nextInt();

        int num2 = scan.nextInt();

        nums.add(new Integer(num1));

        nums.add(new Integer(num2));

    }catch(InputMismatchException immExp){

        throw immExp;

    }finally {

        scan.close();

    }

    return nums;

}

//執行加法計算

private static int add() throws Exception

{

    int result;

    try {

        Listnums =getInputNumbers();

        result = nums.get(0)  + nums.get(1);

    }catch(InputMismatchException immExp){

        throw new Exception("計算失敗",immExp);  /////////////////////////////鏈化:以一個異常對象為參數構造新的異常對象。

    }

    return  result;

}

/*

請輸入2個加數

r 1

java.lang.Exception: 計算失敗

    at practise.ExceptionTest.add(ExceptionTest.java:53)

    at practise.ExceptionTest.main(ExceptionTest.java:18)

Caused by: 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 practise.ExceptionTest.getInputNumbers(ExceptionTest.java:30)

    at practise.ExceptionTest.add(ExceptionTest.java:48)

    ... 1 more

*/

由于“JAVA中異常與異常處理詳解”內容太多，本文以滿，請看下文：http://m.dabaquan.cn/javazixun/1829.html

相關視頻教程推薦

java初級入門教程下載——Java自定義異常：http://m.dabaquan.cn/xiazai/1023.html

java初級入門教程下載——異常捕獲預處理：http://m.dabaquan.cn/xiazai/2555.html