程序師世界是廣大編程愛好者互助、分享、學習的平台,程序師世界有你更精彩!
首頁
編程語言
C語言|JAVA編程
Python編程
網頁編程
ASP編程|PHP編程
JSP編程
數據庫知識
MYSQL數據庫|SqlServer數據庫
Oracle數據庫|DB2數據庫
 程式師世界 >> 編程語言 >> JAVA編程 >> 關於JAVA >> Java異常處理原理及應用

Java異常處理原理及應用

編輯:關於JAVA

Java異常處理是使用Java語言進行軟件開發和測試腳本開發時不容忽視的問題之一,是否進行異常處理直接關系到開發出的軟件的穩定性和健壯性。我們曾經為大家介紹過《全面掌握Java的異常處理機制》,本文闡述了Java 異常處理的原理,並列舉了一些實例。

Java 異常處理引出

假設您要編寫一個 Java 程序,該程序讀入用戶輸入的一行文本,並在終端顯示該文本。

程序如下:

  1. import Java.io.*;  
  2. public class EchoInput {  
  3.      public static void main(String args[]){  
  4.          System.out.println("Enter text to echo:");  
  5.          InputStreamReader isr = new InputStreamReader(System.in);  
  6.          BufferedReader inputReader = new BufferedReader(isr);  
  7.          String inputLine = inputReader.readLine();  
  8.          System.out.println("Read:" + inputLine);  
  9.   }  
  10. }  

分析上面的代碼,在 EchoInput 類中,第 3 行聲明了 main 方法;第 4 行提示用戶輸入文本;第 5、6 行設置 BufferedReader 對像連接到 InputStreamReader,而 InputStreamReader 又連接到標准輸入流 System.in;第 7 行讀入一行文本;第 8 行用標准輸出流 System.out 顯示出該文本。

表面看來上面的程序沒有問題,但實際上,EchoInput 類完全可能出現問題。要在調用第 7 行的 readLine 方法時正確讀取輸入,這幾種假設都必須成立:假定鍵盤有效,鍵盤能與計算機正常通信;假定鍵盤數據可從操作系統傳輸到 Java 虛擬機,又從 Java 虛擬機傳輸 inputReader。

大多數情況下上述假設都成立,但不盡然。為此,Java 采用異常方法,以應對可能出現的錯誤,並采取步驟進行更正。在本例中,若試圖編譯以上代碼,將看到以下信息:

  1. Exception in thread "main" Java.lang.Error: Unresolved compilation problem:  
  2.     Unhandled exception type IOException  
  3.     at EchoInput.main(EchoInput.Java:7)  
  4.  

從中可以看到,第 7 行調用 readLine 方法可能出錯:若果真如此,則產生 IOException 來記錄故障。編譯器錯誤是在告訴您,需要更改代碼來解決這個潛在的問題。在 JDK API 文檔中,可以看到同樣的信息。我們可以看到 readLine 方法,如圖 1 所示。

圖 1. BufferedReader 類的 readLine 方法的 JDK API 文檔
BufferedReader 類的 readLine 方法的 JDK API 文檔

由上圖可知,readLine 方法有時產生 IOException。如何處理潛在的故障?編譯器需要“捕獲”或“聲明”IOException。

“捕獲 (catch)”指當 readLine 方法產生錯誤時截獲該錯誤,並處理和記錄該問題。而“聲明 (declare)”指錯誤可能引發 IOException,並通知調用該方法的任何代碼:可能產生異常。

若要捕獲異常,必須添加一個特殊的“處理代碼塊”,來接收和處理 IOException。於是程序改為如下:

  1. import Java.io.*;  
  2. public class EchoInputHandle {  
  3.      public static void main(String args[]){  
  4.          System.out.println("Enter text to echo:");  
  5.          InputStreamReader isr = new InputStreamReader(System.in);  
  6.          BufferedReader inputReader = new BufferedReader(isr);  
  7.          try{  
  8.              String inputLine = inputReader.readLine();  
  9.              System.out.println("Read:" + inputLine);  
  10.          }  
  11.          catch(IOException exc){  
  12.              System.out.println(“Exception encountered: ” + exc);  
  13.          }  
  14.      }  
  15. }  

新添的代碼塊包含關鍵字 try 和 catch(第 7,10,11,13 行),表示要讀取輸入。若成功,則正常運行。若讀取輸入時錯誤,則捕獲問題(由 IOException 對象表示),並采取相應措施。在本例,采用的處理方式是輸出異常。

若不准備捕獲 IOException,僅聲明異常,則要特別指定 main 方法可能出錯,而且特別說明可能產生 IOException。於是程序改為如下:

  1. import Java.io.*;  
  2. public class EchoInputDeclare {  
  3.      public static void main(String args[]) throws IOException{  
  4.          System.out.println("Enter text to echo:");  
  5.          InputStreamReader isr = new InputStreamReader(System.in);  
  6.          BufferedReader inputReader = new BufferedReader(isr);  
  7.          String inputLine = inputReader.readLine();  
  8.          System.out.println("Read:" + inputLine);  
  9.   }  
  10. }  

從上面的這個簡單的例子中,我們可以看出異常處理在 Java 代碼開發中不能被忽視。

Java 異常以及異常處理

可將 Java 異常看作是一類消息,它傳送一些系統問題、故障及未按規定執行的動作的相關信息。異常包含信息,以將信息從應用程序的一部分發送到另一部分。

編譯語言為何要處理異常?為何不在異常出現位置隨時處理具體故障?因為有時候我們需要在系統中交流錯誤消息,以便按照統一的方式處理問題,有時是因為有若干處理問題的可能方式,但您不知道使用哪一種,此時,可將處理異常的任務委托給調用方法的代碼。調用者通常更能了解問題來源的上下文,能更好的確定恢復方式。

圖 2. 通用消息架構 
通用消息架構

從上圖可以看出,必定在運行的 Java 應用程序的一些類或對象中產生異常。出現故障時,“發送者”將產生異常對象。異常可能代表 Java 代碼出現的問題,也可能是 JVM 的相應錯誤,或基礎硬件操作系統的錯誤。

異常本身表示消息,指發送者傳給接收者的數據“負荷”。首先,異常基於類的類型來傳輸有用信息。很多情況下,基於異常的類既能識別故障本因並能更正問題。其次,異常還帶有可能有用的數據(如屬性)。

在處理異常時,消息必須有接收者;否則將無法處理產生異常的底層問題。

在上例中,異常“產生者”是讀取文本行的 BufferedReader。在故障出現時,將在 readLine 方法中構建 IOException 對象。異常“接收者”是代碼本身。EchoInputHandle 應用程序的 try-catch 結構中的 catch 塊是異常的接收者,它以字符串形式輸出異常,將問題記錄下來。

Java 異常類的層次結構

在我們從總體上了解異常後,我們應該了解如何在 Java 應用程序中使用異常,即需要了解 Java 類的層次結構。圖 3 是 Java 類的層次結構圖。

圖 3. Java 類的層次結構 
 Java 類的層次結構

在 Java 中,所有的異常都有一個共同的祖先 Throwable(可拋出)。Throwable 指定代碼中可用異常傳播機制通過 Java 應用程序傳輸的任何問題的共性。

Throwable 有兩個重要的子類:Exception(異常)和 Error(錯誤),二者都是 Java 異常處理的重要子類,各自都包含大量子類。

Exception(異常)是應用程序中可能的可預測、可恢復問題。一般大多數異常表示中度到輕度的問題。異常一般是在特定環境下產生的,通常出現在代碼的特定方法和操作中。在 EchoInput 類中,當試圖調用 readLine 方法時,可能出現 IOException 異常。

Error(錯誤)表示運行應用程序中較嚴重問題。大多數錯誤與代碼編寫者執行的操作無關,而表示代碼運行時 JVM(Java 虛擬機)出現的問題。例如,當 JVM 不再有繼續執行操作所需的內存資源時,將出現 OutOfMemoryError。

Exception 類有一個重要的子類 RuntimeException。RuntimeException 類及其子類表示“JVM 常用操作”引發的錯誤。例如,若試圖使用空值對象引用、除數為零或數組越界,則分別引發運行時異常(NullPointerException、ArithmeticException)和 ArrayIndexOutOfBoundException。

Java 異常的處理

在 Java 應用程序中,對異常的處理有兩種方式:處理異常和聲明異常。

處理異常:try、catch 和 finally

若要捕獲異常,則必須在代碼中添加異常處理器塊。這種 Java 結構可能包含 3 個部分,

都有 Java 關鍵字。下面的例子中使用了 try-catch-finally 代碼結構。

  1. import Java.io.*;  
  2. public class EchoInputTryCatchFinally {  
  3.      public static void main(String args[]){  
  4.          System.out.println("Enter text to echo:");  
  5.          InputStreamReader isr = new InputStreamReader(System.in);  
  6.          BufferedReader inputReader = new BufferedReader(isr);  
  7.          try{  
  8.              String inputLine = inputReader.readLine();  
  9.             System.out.println("Read:" + inputLine);       
  10.          }  
  11.          catch(IOException exc){  
  12.              System.out.println("Exception encountered: " + exc);  
  13.          }  
  14.          finally{  
  15.             System.out.println("End. ");  
  16.      }  
  17. }  
  18.  

其中:

try 塊:將一個或者多個語句放入 try 時,則表示這些語句可能拋出異常。編譯器知道可能要發生異常,於是用一個特殊結構評估塊內所有語句。

catch 塊:當問題出現時,一種選擇是定義代碼塊來處理問題,catch 塊的目的便在於此。catch 塊是 try 塊所產生異常的接收者。基本原理是:一旦生成異常,則 try 塊的執行中止,JVM 將查找相應的 JVM。

finally 塊:還可以定義 finally 塊,無論運行 try 塊代碼的結果如何,該塊裡面的代碼一定運行。在常見的所有環境中,finally 塊都將運行。無論 try 塊是否運行完,無論是否產生異常,也無論是否在 catch 塊中得到處理,finally 塊都將執行。

try-catch-finally 規則:

必須在 try 之後添加 catch 或 finally 塊。try 塊後可同時接 catch 和 finally 塊,但至少有一個塊。

必須遵循塊順序:若代碼同時使用 catch 和 finally 塊,則必須將 catch 塊放在 try 塊之後。

catch 塊與相應的異常類的類型相關。

一個 try 塊可能有多個 catch 塊。若如此,則執行第一個匹配塊。

可嵌套 try-catch-finally 結構。

在 try-catch-finally 結構中,可重新拋出異常。

除了下列情況,總將執行 finally 做為結束:JVM 過早終止(調用 System.exit(int));在 finally 塊中拋出一個未處理的異常;計算機斷電、失火、或遭遇病毒攻擊。

聲明異常

若要聲明異常,則必須將其添加到方法簽名塊的結束位置。下面是一個實例:

  1. public void errorProneMethod(int input) throws Java.io.IOException {  
  2.     //Code for the method,including one or more method  
  3.     //calls that may produce an IOException  
  4. }  

這樣,聲明的異常將傳給方法調用者,而且也通知了編譯器:該方法的任何調用者必須遵守處理或聲明規則。聲明異常的規則如下:

必須聲明方法可拋出的任何可檢測異常(checked exception)。

非檢測性異常(unchecked exception)不是必須的,可聲明,也可不聲明。

調用方法必須遵循任何可檢測異常的處理和聲明規則。若覆蓋一個方法,則不能聲明與覆蓋方法不同的異常。聲明的任何異常必須是被覆蓋方法所聲明異常的同類或子類。

Java 異常處理的分類

Java 異常可分為可檢測異常,非檢測異常和自定義異常。

可檢測異常

可檢測異常經編譯器驗證,對於聲明拋出異常的任何方法,編譯器將強制執行處理或聲明規則,例如:sqlExecption 這個異常就是一個檢測異常。你連接 JDBC 時,不捕捉這個異常,編譯器就通不過,不允許編譯。

非檢測異常

非檢測異常不遵循處理或聲明規則。在產生此類異常時,不一定非要采取任何適當操作,編譯器不會檢查是否已解決了這樣一個異常。例如:一個數組為 3 個長度,當你使用下標為3時,就會產生數組下標越界異常。這個異常 JVM 不會進行檢測,要靠程序員來判斷。有兩個主要類定義非檢測異常:RuntimeException 和 Error。

Error 子類屬於非檢測異常,因為無法預知它們的產生時間。若 Java 應用程序內存不足,則隨時可能出現 OutOfMemoryError;起因一般不是應用程序的特殊調用,而是 JVM 自身的問題。另外,Error 一般表示應用程序無法解決的嚴重問題。

RuntimeException 類也屬於非檢測異常,因為普通 JVM 操作引發的運行時異常隨時可能發生,此類異常一般是由特定操作引發。但這些操作在 Java 應用程序中會頻繁出現。因此,它們不受編譯器檢查與處理或聲明規則的限制。

自定義異常

自定義異常是為了表示應用程序的一些錯誤類型,為代碼可能發生的一個或多個問題提供新含義。可以顯示代碼多個位置之間的錯誤的相似性,也可以區分代碼運行時可能出現的相似問題的一個或者多個錯誤,或給出應用程序中一組錯誤的特定含義。例如,對隊列進行操作時,有可能出現兩種情況:空隊列時試圖刪除一個元素;滿隊列時試圖添加一個元素。則需要自定義兩個異常來處理這兩種情況。

Java 異常處理的原則和忌諱

Java 異常處理的原則

盡可能的處理異常

要盡可能的處理異常,如果條件確實不允許,無法在自己的代碼中完成處理,就考慮聲明異常。如果人為避免在代碼中處理異常,僅作聲明,則是一種錯誤和依賴的實踐。

具體問題具體解決

異常的部分優點在於能為不同類型的問題提供不同的處理操作。有效異常處理的關鍵是識別特定故障場景,並開發解決此場景的特定相應行為。為了充分利用異常處理能力,需要為特定類型的問題構建特定的處理器塊。

記錄可能影響應用程序運行的異常

至少要采取一些永久的方式,記錄下可能影響應用程序操作的異常。理想情況下,當然是在第一時間解決引發異常的基本問題。不過,無論采用哪種處理操作,一般總應記錄下潛在的關鍵問題。別看這個操作很簡單,但它可以幫助您用很少的時間來跟蹤應用程序中復雜問題的起因。

根據情形將異常轉化為業務上下文

若要通知一個應用程序特有的問題,有必要將應用程序轉換為不同形式。若用業務特定狀態表示異常,則代碼更易維護。從某種意義上講,無論何時將異常傳到不同上下文(即另一技術層),都應將異常轉換為對新上下文有意義的形式。

Java 異常處理的忌諱

一般不要忽略異常

在異常處理塊中,一項最危險的舉動是“不加通告”地處理異常。如下例所示:

  1. try{  
  2.     Class.forName("business.domain.Customer");  
  3. }  
  4. catch (ClassNotFoundException exc){}  

經常能夠在代碼塊中看到類似的代碼塊。有人總喜歡在編寫代碼時簡單快速地編寫空處理器塊,並“自我安慰地”宣稱准備在“後期”添加恢復代碼,但這個“後期”變成了“無期”。

這種做法有什麼壞處?如果異常對應用程序的其他部分確實沒有任何負面影響,這未嘗不可。但事實往往並非如此,異常會擾亂應用程序的狀態。此時,這樣的代碼無異於掩耳盜鈴。

這種做法若影響較輕,則應用程序可能出現怪異行為。例如,應用程序設置的一個值不見了, 或 GUI 失效。若問題嚴重,則應用程序可能會出現重大問題,因為異常未記錄原始故障點,難以處理,如重復的 NullPointerExceptions。

如果采取措施,記錄了捕獲的異常,則不可能遇到這個問題。實際上,除非確認異常對代碼其余部分絕無影響,至少也要作記錄。進一步講,永遠不要忽略問題;否則,風險很大,在後期會引發難以預料的後果。

不要使用覆蓋式異常處理塊

另一個危險的處理是覆蓋式處理器(blanket handler)。該代碼的基本結構如下:

  1. try{  
  2.   // …  
  3. }  
  4. catch(Exception e){  
  5.   // …  
  6. }  

使用覆蓋式異常處理塊有兩個前提之一:

1. 代碼中只有一類問題。

這可能正確,但即便如此,也不應使用覆蓋式異常處理,捕獲更具體的異常形式有利物弊。

2. 單個恢復操作始終適用。

這幾乎絕對錯誤。幾乎沒有哪個方法能放之四海而皆准,能應對出現的任何問題。

分析下這樣編寫代碼將發生的情況。只要方法不斷拋出預期的異常集,則一切正常。但是,如果拋出了未預料到的異常,則無法看到要采取的操作。當覆蓋式處理器對新異常類執行千篇一律的任務時,只能間接看到異常的處理結果。如果代碼沒有打印或記錄語句,則根本看不到結果。

更糟糕的是,當代碼發生變化時,覆蓋式處理器將繼續作用於所有新異常類型,並以相同方式處理所有類型。

一般不要把特定的異常轉化為更通用的異常

將特定的異常轉換為更通用異常時一種錯誤做法。一般而言,這將取消異常起初拋出時產生的上下文,在將異常傳到系統的其他位置時,將更難處理。見下例:

  1. try{  
  2.   // Error-prone code  
  3. }  
  4. catch(IOException e){  
  5.    String msg = "If you didn ’ t have a problem before,you do now!";  
  6.    throw new Exception(msg);  
  7. }  

因為沒有原始異常的信息,所以處理器塊無法確定問題的起因,也不知道如何更正問題。

不要處理能夠避免的異常

對於有些異常類型,實際上根本不必處理。通常運行時異常屬於此類范疇。在處理空指針或者數據索引等問題時,不必求助於異常處理。

Java 異常處理的應用實例

在定義銀行類時,若取錢數大於余額時需要做異常處理。

定義一個異常類 insufficIEntFundsException。取錢(withdrawal)方法中可能產生異常,條件是余額小於取額。

處理異常在調用 withdrawal 的時候,因此 withdrawal 方法要聲明拋出異常,由上一級方法調用。

異常類:

  1. class InsufficIEntFundsExceptionextends Exception{  
  2.    private Bank  excepbank;      // 銀行對象  
  3.    private double excepAmount;   // 要取的錢  
  4.    InsufficIEntFundsException(Bank ba, double  dAmount)  
  5.     {  excepbank=ba;  
  6.        excepAmount=dAmount;  
  7.    }  
  8.    public String excepMessage(){  
  9.       String  str="The balance is"+excepbank.balance  
  10.        + "\n"+"The withdrawal was"+excepAmount;  
  11.       return str;    
  12.    }  
  13. }// 異常類  
  14.  

銀行類:

  1. class Bank{  
  2.    double balance;// 存款數  
  3.    Bank(double  balance){this.balance=balance;}  
  4.    public void deposite(double dAmount){  
  5.      if(dAmount>0.0) balance+=dAmount;  
  6.    }  
  7.    public void withdrawal(double dAmount)  
  8.                throws  InsufficIEntFundsException{  
  9.      if (balance<dAmount)     throw new  
  10.           InsufficIEntFundsException(this, dAmount);  
  11.       balancebalance=balance-dAmount;  
  12.    }  
  13.    public void showBalance(){  
  14.       System.out.println("The balance is "+(int)balance);  
  15.    }  
  16. }  
  17.  

前端調用:

  1. public class ExceptionDemo{  
  2.    public static void main(String args[]){  
  3.      try{  
  4.         Bank ba=new Bank(50);  
  5.           ba.withdrawal(100);  
  6.           System.out.println("Withdrawal successful!");  
  7.       }catch(InsufficIEntFundsException e) {   
  8.           System.out.println(e.toString());  
  9.           System.out.println(e.excepMessage());  
  10.       }  
  11.    }  
  12. }  
  13.  

總結

Java 異常處理是使用 Java 語言進行軟件開發和測試腳本開發中非常重要的一個方面。對異常處理的重視會是您開發出的代碼更健壯,更穩定。本文系統的闡述了 Java 異常處理的原理和方法。能幫助讀者更加清楚的理解 Java 異常處理機制,在開發代碼時更加靈活的使用它。

  1. 上一頁:
  2. 下一頁:
Copyright © 程式師世界 All Rights Reserved