Java提高篇——Java 異常處理
異常的概念
異常是程式中的一些錯誤,但並不是所有的錯誤都是異常,並且錯誤有時候是可以避免的。
比如說,你的程式碼少了一個分號,那麼執行出來結果是提示是錯誤java.lang.Error
;如果你用System.out.println(11/0)
,那麼你是因為你用0做了除數,會丟擲java.lang.ArithmeticException
的異常。
異常發生的原因有很多,通常包含以下幾大類:
- 使用者輸入了非法資料。
- 要開啟的檔案不存在。
- 網路通訊時連線中斷,或者JVM記憶體溢位。
這些異常有的是因為使用者錯誤引起,有的是程式錯誤引起的,還有其它一些是因為物理錯誤引起的。-
要理解Java異常處理是如何工作的,你需要掌握以下三種類型的異常:
- 檢查性異常:最具代表的檢查性異常是使用者錯誤或問題引起的異常,這是程式設計師無法預見的。例如要開啟一個不存在檔案時,一個異常就發生了,這些異常在編譯時不能被簡單地忽略。
- 執行時異常: 執行時異常是可能被程式設計師避免的異常。與檢查性異常相反,執行時異常可以在編譯時被忽略。
- 錯誤: 錯誤不是異常,而是脫離程式設計師控制的問題。錯誤在程式碼中通常被忽略。例如,當棧溢位時,一個錯誤就發生了,它們在編譯也檢查不到的。
異常指不期而至的各種狀況,如:檔案找不到、網路連線失敗、除0操作、非法引數等。異常是一個事件,它發生在程式執行期間,干擾了正常的指令流程。
Java語言在設計的當初就考慮到這些問題,提出異常處理的框架的方案,所有的異常都可以用一個異常類來表示,不同型別的異常對應不同的子類異常(目前我們所說的異常包括錯誤概念),定義異常處理的規範,在JDK1.4
Java異常是一個描述在程式碼段中發生異常的物件,當發生異常情況時,一個代表該異常的物件被建立並且在導致該異常的方法中被丟擲,而該方法可以選擇自己處理異常或者傳遞該異常。
異常的體系結構
Java把異常當作物件來處理,並定義一個基類java.lang.Throwable
作為所有異常的超類。
在Java API中已經定義了許多異常類,這些異常類分為兩大類,錯誤Error
和異常Exception
。
Java異常層次結構圖如下圖所示:
從圖中可以看出所有異常型別都是內建類Throwable
的子類,因而Throwable
在異常類的層次結構的頂層。
接下來Throwable
Error
,它表示不希望被程式捕獲或者是程式無法處理的錯誤。另一個分支是Exception
,它表示使用者程式可能捕捉的異常情況或者說是程式可以處理的異常。其中異常類Exception
又分為執行時異常(RuntimeException
)和非執行時異常。Java異常又可以分為不受檢查異常(Unchecked Exception
)和檢查異常(Checked Exception
)。
下面將詳細講述這些異常之間的區別與聯絡:
Error
:Error
類物件由 Java 虛擬機器生成並丟擲,大多數錯誤與程式碼編寫者所執行的操作無關。例如,Java虛擬機器執行錯誤(Virtual MachineError
),當JVM不再有繼續執行操作所需的記憶體資源時,將出現OutOfMemoryError
。這些異常發生時,Java虛擬機器(JVM)一般會選擇執行緒終止;還有發生在虛擬機器試圖執行應用時,如類定義錯誤(NoClassDefFoundError
)、連結錯誤(LinkageError
)。這些錯誤是不可查的,因為它們在應用程式的控制和處理能力之 外,而且絕大多數是程式執行時不允許出現的狀況。對於設計合理的應用程式來說,即使確實發生了錯誤,本質上也不應該試圖去處理它所引起的異常狀況。在Java中,錯誤通常是使用Error
的子類描述。Exception
:在Exception
分支中有一個重要的子類RuntimeException
(執行時異常),該型別的異常自動為你所編寫的程式定義ArrayIndexOutOfBoundsException
(陣列下標越界)、NullPointerException
(空指標異常)、ArithmeticException
(算術異常)、MissingResourceException
(丟失資源)、ClassNotFoundException
(找不到類)等異常,這些異常是不檢查異常,程式中可以選擇捕獲處理,也可以不處理。這些異常一般是由程式邏輯錯誤引起的,程式應該從邏輯角度儘可能避免這類異常的發生;而RuntimeException
之外的異常我們統稱為非執行時異常,型別上屬於Exception
類及其子類,從程式語法角度講是必須進行處理的異常,如果不處理,程式就不能編譯通過。如IOException
、SQLException
等以及使用者自定義的Exception
異常,一般情況下不自定義檢查異常。
注意
Error
和Exception
的區別:Error
通常是災難性的致命的錯誤,是程式無法控制和處理的,當出現這些異常時,Java虛擬機器(JVM)一般會選擇終止執行緒;Exception
通常情況下是可以被程式處理的,並且在程式中應該儘可能的去處理這些異常。
檢查異常
:在正確的程式執行過程中,很容易出現的、情理可容的異常狀況,在一定程度上這種異常的發生是可以預測的,並且一旦發生該種異常,就必須採取某種方式進行處理。
♠提示
除了
RuntimeException
及其子類以外,其他的Exception
類及其子類都屬於檢查異常,當程式中可能出現這類異常,要麼使用try-catch
語句進行捕獲,要麼用throws
子句丟擲,否則編譯無法通過。
不受檢查異常
:包括RuntimeException
及其子類和Error
。
♠提示
不受檢查異常
為編譯器不要求強制處理的異常,檢查異常
則是編譯器要求必須處置的異常。
Java的異常處理本質上是丟擲異常和捕獲異常。
丟擲異常
:要理解丟擲異常,首先要明白什麼是異常情形(exception condition),它是指阻止當前方法或作用域繼續執行的問題。其次把異常情形和普通問題相區分,普通問題是指在當前環境下能得到足夠的資訊,總能處理這個錯誤。對於異常情形,已經無法繼續下去了,因為在當前環境下無法獲得必要的資訊來解決問題,你所能做的就是從當前環境中跳出,並把問題提交給上一級環境,這就是丟擲異常時所發生的事情。丟擲異常後,會有幾件事隨之發生。首先,是像建立普通的java物件一樣將使用new
在堆上建立一個異常物件;然後,當前的執行路徑(已經無法繼續下去了)被終止,並且從當前環境中彈出對異常物件的引用。此時,異常處理機制接管程式,並開始尋找一個恰當的地方繼續執行程式,這個恰當的地方就是異常處理程式或者異常處理器,它的任務是將程式從錯誤狀態中恢復,以使程式要麼換一種方式執行,要麼繼續執行下去。
舉個簡單的例子,假使我們建立了一個學生物件Student的一個引用stu,在呼叫的時候可能還沒有初始化。所以在使用這個物件引用呼叫其他方法之前,要先對它進行檢查,可以建立一個代表錯誤資訊的物件,並且將它從當前環境中丟擲,這樣就把錯誤資訊傳播到更大的環境中。
if(stu == null){ throw new NullPointerException(); }
這就丟擲了異常,它將在其他的地方得到執行或者處理,具體是哪個地方後面將很快介紹,程式碼中出現的 throw
是一個關鍵字,暫時先不做過多講解,後面會詳細講解。
捕獲異常
:在方法丟擲異常之後,執行時系統將轉為尋找合適的異常處理器(exception handler)。潛在的異常處理器是異常發生時依次存留在呼叫棧中的方法的集合。當異常處理器所能處理的異常型別與方法丟擲的異常型別相符時,即為合適的異常處理器。執行時系統從發生異常的方法開始,依次回查呼叫棧中的方法,直至找到含有合適異常處理器的方法並執行。當執行時系統遍歷呼叫棧而未找到合適的異常處理器,則執行時系統終止。同時,意味著Java程式的終止。
提示
對於
執行時異常
、錯誤
和檢查異常
,Java技術所要求的異常處理方式有所不同。由於執行時異常及其子類的不可查性,為了更合理、更容易地實現應用程式,Java規定,執行時異常將由Java執行時系統自動丟擲,允許應用程式忽略執行時異常。
對於方法執行中可能出現的
Error
,當執行方法不欲捕捉時,Java允許該方法不做任何丟擲宣告。因為,大多數Error
異常屬於永遠不能被允許發生的狀況,也屬於合理的應用程式不該捕捉的異常。對於所有的檢查異常,Java規定:一個方法必須捕捉,或者宣告丟擲方法之外。也就是說,當一個方法選擇不捕捉檢查異常時,它必須宣告將丟擲異常。
Java異常處理涉及到五個關鍵字,分別是:try
、catch
、finally
、throw
、throws
。下面將驟一介紹,通過認識這五個關鍵字,掌握基本異常處理知識。
• try -- 用於監聽。將要被監聽的程式碼(可能丟擲異常的程式碼)放在try語句塊之內,當try語句塊內發生異常時,異常就被丟擲。
• catch -- 用於捕獲異常。catch用來捕獲try語句塊中發生的異常。
• finally -- finally語句塊總是會被執行。它主要用於回收在try塊裡開啟的物力資源(如資料庫連線、網路連線和磁碟檔案)。只有finally塊,執行完成之後,才會回來執行try或者catch塊中的return或者throw語句,如果finally中使用了return或者throw等終止方法的語句,則就不會跳回執行,直接停止。
• throw -- 用於丟擲異常。
• throws -- 用在方法簽名中,用於宣告該方法可能丟擲的異常。
異常處理的基本語法
1. try-catch
try{ //code that might generate exceptions }catch(Exception e){ //the code of handling exception1 }catch(Exception e){ //the code of handling exception2 }
要明白異常捕獲,還要理解監控區域
(guarded region)的概念。它是一段可能產生異常的程式碼,並且後面跟著處理這些異常的程式碼。
因而可知,上述try-catch
所描述的即是監控區域,關鍵詞try
後的一對大括號將一塊可能發生異常的程式碼包起來,即為監控區域。Java方法在執行過程中發生了異常,則建立異常物件。將異常丟擲監控區域之外,由Java執行時系統負責尋找匹配的catch
子句來捕獲異常。若有一個catch
語句匹配到了,則執行該catch
塊中的異常處理程式碼,就不再嘗試匹配別的catch
塊了。
匹配的原則是:如果丟擲的異常物件屬於
catch
子句的異常類,或者屬於該異常類的子類,則認為生成的異常物件與catch
塊捕獲的異常型別相匹配。
舉個例子算術異常:
public class TestException { public static void main(String[] args) { int a = 1; int b = 0; try { // try監控區域 if (b == 0) throw new ArithmeticException(); // 通過throw語句丟擲異常 System.out.println("a/b的值是:" + a / b); System.out.println("this will not be printed!"); } catch (ArithmeticException e) { // catch捕捉異常 System.out.println("程式出現異常,變數b不能為0!"); } System.out.println("程式正常結束。"); } }
執行結果:
D:\java>java TestException
程式出現異常,變數b不能為0!
程式正常結束。
顯示一個異常的描述,
Throwable
過載了toString()
方法(由Object
定義),所以它將返回一個包含異常描述的字串。例如,將前面的catch
塊重寫成:catch (ArithmeticException e) { // catch捕捉異常 System.out.println("程式出現異常"+e); }結果:
D:\java>java TestException 程式出現異常java.lang.ArithmeticException 程式正常結束。
根據前面講述的,算術異常屬於執行時異常,因而實際上該異常不需要程式丟擲,執行時系統自動丟擲,將例子改為如下:
public class TestException { public static void main(String[] args) { int a = 1; int b = 0; System.out.println("a/b的值是:" + a / b); System.out.println("this will not be printed!"); } }
結果:
D:\java>java TestException Exception in thread "main" java.lang.ArithmeticException: / by zero at TestException.main(TestException.java:7)
使用多重的catch語句
:很多情況下,由單個的程式碼段可能引起多個異常。處理這種情況,我們需要定義兩個或者更多的catch
子句,每個子句捕獲一種型別的異常,當異常被引發時,每個catch
子句被依次檢查,第一個匹配異常型別的子句執行,當一個catch
子句執行以後,其他的子句將被旁路。
編寫多重catch語句塊注意事項:
順序問題:先小後大,即先子類後父類
Java通過異常類描述異常型別。對於有多個
catch
子句的異常程式而言,應該儘量將捕獲底層異常類的catch
子句放在前面,同時儘量將捕獲相對高層的異常類的catch
子句放在後面。否則,捕獲底層異常類的catch
子句將可能會被遮蔽。
RuntimeException
異常類包括執行時各種常見的異常,ArithmeticException
類和ArrayIndexOutOfBoundsException
類都是它的子類。因此,RuntimeException
異常類的catch
子句應該放在最後面,否則可能會遮蔽其後的特定異常處理或引起編譯錯誤。
巢狀try語句
:try
語句可以被巢狀。也就是說,一個try
語句可以在另一個try
塊的內部。每次進入try
語句,異常的前後關係都會被推入堆疊。如果一個內部的try
語句不含特殊異常的catch
處理程式,堆疊將彈出,下一個try
語句的catch
處理程式將檢查是否與之匹配。這個過程將繼續直到一個catch
語句被匹配成功,或者是直到所有的巢狀try
語句被檢查完畢。如果沒有catch
語句匹配,Java執行時系統將處理這個異常。
例如:
class NestTry{ public static void main(String[] args){ try{ int a = args.length; int b = 42 / a; System.out.println("a = "+ a); try{ if(a == 1){ a = a/(a-a); } if(a == 2){ int c[] = {1}; c[42] =99; } }catch(ArrayIndexOutOfBoundsException e){ System.out.println("ArrayIndexOutOfBounds :"+e); } }catch(ArithmeticException e){ System.out.println("Divide by 0"+ e); } } }
正如程式中所顯示的,該程式在一個try塊中嵌套了另一個try
塊。程式工作如下:當你在沒有命令列引數的情況下執行該程式,外面的try
塊將產生一個被0除的異常。程式在有一個命令列引數條件下執行,由巢狀的try
塊產生一個被0除的異常,由於內部的catch
塊不匹配這個異常,它將把異常傳給外部的try
塊,在外部異常被處理。如果你在具有兩個命令列引數的條件下執行該程式,將由內部try
塊產生一個數組邊界異常。
結果:
D:\java>javac estTry.java D:\java>>java NestTry Divide by 0 java.lang.ArithmeticExceptio: / by zero D:\java>java NestTry one a = 1 Divide by 0java.lang.ArithmeticException: / by zero D:\java>java NestTry one two a = 2 ArrayIndexOutOfBounds :java.lang.ArrayIndexOutOfBoundsException: 42
注意:當有方法呼叫時,try
語句的巢狀可以很隱蔽的發生。例如,我們可以將對方法的呼叫放在一個try
塊中。在該方法的內部,有另一個try
語句。在這種情況下,方法內部的try
仍然是巢狀在外部呼叫該方法的try
塊中的。下面我們將對上述例子進行修改,巢狀的try
塊移到方法nesttry()的內部:
class NestTry{ static void nesttry(int a){ try{ if(a == 1){ a = a/(a-a); } if(a == 2){ int c[] = {1}; c[42] =99; } }catch(ArrayIndexOutOfBoundsException e){ System.out.println("ArrayIndexOutOfBounds :"+e); } } public static void main(String[] args){ try{ int a = args.length; int b = 42 / a; System.out.println("a = "+ a); nesttry(a); }catch(ArithmeticException e){ System.out.println("Divide by 0"+ e); } } }
結果輸出與前面例子一致:
D:\java>javac NestTry.java D:\java>java NestTry Divide by 0java.lang.ArithmeticException: / by zero D:\java>java NestTry one a = 1 Divide by 0java.lang.ArithmeticException: / by zero D:\java>java NestTry one two a = 2 ArrayIndexOutOfBounds :java.lang.ArrayIndexOutOfBoundsException: 42
2. throw
到目前為止,我們只是獲取了被Java執行時系統引發的異常。然而,我們還可以用throw
語句丟擲明確的異常。Throw
的語法形式如下:
throw ThrowableInstance;
這裡的ThrowableInstance一定是Throwable
類型別或者Throwable
子類型別的一個物件。簡單的資料型別,例如int
,char
,以及非Throwable
類,例如String
或Object
,不能用作異常。有兩種方法可以獲取Throwable
物件:在catch
子句中使用引數或者使用new
操作符建立。
程式執行完throw
語句之後立即停止;throw
後面的任何語句不被執行,最鄰近的try
塊用來檢查它是否含有一個與異常型別匹配的catch
語句。如果發現了匹配的塊,控制轉向該語句;如果沒有發現,次包圍的try
塊來檢查,以此類推。如果沒有發現匹配的catch
塊,預設異常處理程式中斷程式的執行並且列印堆疊軌跡。
例如:
class TestThrow{ static void proc(){ try{ throw new NullPointerException("demo"); }catch(NullPointerException e){ System.out.println("Caught inside proc"); throw e; } } public static void main(String [] args){ try{ proc(); }catch(NullPointerException e){ System.out.println("Recaught: "+e); } } }
結果:
D:\java>java TestThrow
Caught inside proc
Recaught: java.lang.NullPointerException: demo
該程式兩次處理相同的錯誤,首先,main()
方法設立了一個異常關係然後呼叫proc()。proc()方法設立了另一個異常處理關係並且立即丟擲一個NullPointerException
例項,NullPointerException
在main()
中被再次捕獲。
該程式闡述了怎樣建立Java的標準異常物件,特別注意這一行:
1 | throw new NullPointerException( "demo" ); |
此處
new
用來構造一個NullPointerException
例項,所有的Java內建的執行時異常有兩個構造方法:一個沒有引數,一個帶有一個字串引數。當用第二種形式時,引數指定描述異常的字串。如果物件用作print()
或者println()
的引數時,該字串被顯示。這同樣可以通過呼叫getMessage()來實現,getMessage()是由Throwable
定義的。
3. throws
如果一個方法可以導致一個異常但不處理它,它必須指定這種行為以使方法的呼叫者可以保護它們自己而不發生異常。要做到這點,我們可以在方法宣告中包含一個throws
子句。一個throws
子句列舉了一個方法可能引發的所有異常型別。這對於除了Error
或RuntimeException
及它們子類以外型別的所有異常是必要的。一個方法可以引發的所有其他型別的異常必須在throws
子句中宣告,否則會導致編譯錯誤。
下面是throws
子句的方法宣告的通用形式:
public void info() throws Exception { //body of method }
Exception 是該方法可能引發的所有的異常,也可以是異常列表,中間以逗號隔開。
例如:
class TestThrows{ static void throw1(){ System.out.println("Inside throw1 . "); throw new IllegalAccessException("demo"); } public static void main(String[] args){ throw1(); } }
上述例子中有兩個地方存在錯誤,你能看出來嗎?
該例子中存在兩個錯誤,首先,throw1()方法不想處理所導致的異常,因而它必須宣告throws
子句來列舉可能引發的異常即IllegalAccessException
;其次,main()
方法必須定義try/catch
語句來捕獲該異常。
正確例子如下:
class TestThrows{ static void throw1() throws IllegalAccessException { System.out.println("Inside throw1 . "); throw new IllegalAccessException("demo"); } public static void main(String[] args){ try { throw1(); }catch(IllegalAccessException e ){ System.out.println("Caught " + e); } } }
Throws
丟擲異常的規則:
- 如果是不受檢查異常(
unchecked exception
),即Error
、RuntimeException
或它們的子類,那麼可以不使用throws
關鍵字來宣告要丟擲的異常,編譯仍能順利通過,但在執行時會被系統丟擲。- 必須宣告方法可丟擲的任何檢查異常(
checked exception
)。即如果一個方法可能出現受可查異常,要麼用try-catch
語句捕獲,要麼用throws
子句宣告將它丟擲,否則會導致編譯錯誤- 僅當丟擲了異常,該方法的呼叫者才必須處理或者重新丟擲該異常。當方法的呼叫者無力處理該異常的時候,應該繼續丟擲,而不是囫圇吞棗。
- 呼叫方法必須遵循任何可查異常的處理和宣告規則。若覆蓋一個方法,則不能宣告與覆蓋方法不同的異常。宣告的任何異常必須是被覆蓋方法所宣告異常的同類或子類。
4. finally
當異常發生時,通常方法的執行將做一個陡峭的非線性的轉向,它甚至會過早的導致方法返回。例如,如果一個方法打開了一個檔案並關閉,然後退出,你不希望關閉檔案的程式碼被異常處理機制旁路。finally
關鍵字為處理這種意外而設計。
finally
建立的程式碼塊在try/catch
塊完成之後另一個try/catch
出現之前執行。finally
塊無論有沒有異常丟擲都會執行。如果丟擲異常,即使沒有catch
子句匹配,finally
也會執行。一個方法將從一個try/catch
塊返回到呼叫程式的任何時候,經過一個未捕獲的異常或者是一個明確的返回語句,finally
子句在方法返回之前仍將執行。這在關閉檔案控制代碼和釋放任何在方法開始時被分配的其他資源是很有用。
finally
子句是可選項,可以有也可以無,但是每個try
語句至少需要一個catch
或者finally
子句。
class TestFinally{ static void proc1(){ try{ System.out.println("inside proc1"); throw new RuntimeException("demo"); }finally{ System.out.println("proc1's finally"); } } static void proc2(){ try{ System.out.println("inside proc2"); return ; } finally{ System.out.println("proc2's finally"); } } static void proc3(){ try{ System.out.println("inside proc3"); }finally{ System.out.println("proc3's finally"); } } public static void main(String [] args){ try{ proc1(); }catch(Exception e){ System.out.println("Exception caught"); } proc2(); proc3(); } }
該例子中,proc1()丟擲了異常中斷了try
,它的finally
子句在退出時執行。proc2的try
語句通過return
語句返回,但在返回之前finally
語句執行。在proc3()中try
語句正常執行,沒有錯誤,finally
語句也被執行。
輸出結果:
D:\java>java TestFinally inside proc1 proc1's finally Exception caught inside proc2 proc2's finally inside proc3 proc3's finally
注:如果
finally
塊與一個try
聯合使用,finally
塊將在try
結束之前執行。
問題擴充套件(面試題):
1、try{} 裡有一個 return 語句,那麼緊跟在這個 try 後的 finally{} 裡的 code 會不會被執行,什麼時候被執行,在 return