一、java異常機制
Java提供了兩類主要的異常:runtime exception和checked exception。checked 異常也就是我們經常遇到的IO
異常，以及SQL異常都是這種異常。對於這種異常，JAVA編譯器強制要求我們必需對出現的這些異常進行catch。所以，
面對這種異常不管我們是否願意，只能自己去寫一大堆catch塊去處理可能的異常。
但是另外一種異常：runtime exception，也稱運行時異常，我們可以不處理。當出現這樣的異常時，總是由虛擬
機接管。比如：我們從來沒有人去處理過NullPointerException異常，它就是運行時異常，並且這種異常還是最常見
的異常之一。
出現運行時異常後，系統會把異常一直往上層拋，一直遇到處理代碼。如果沒有處理塊，到最上層，如果是多線程就
由Thread.run()拋出，如果是單線程就被main()拋出。拋出之後，如果是線程，這個線程也就退出了。如果是主程序
拋出的異常，那麼這整個程序也就退出了。運行時異常是Exception的子類，也有一般異常的特點，是可以被Catch塊
處理的。只不過往往我們不對他處理罷了。也就是說，你如果不對運行時異常進行處理，那麼出現運行時異常之後，要
麼是線程中止，要麼是主程序終止。
如果不想終止，則必須撲捉所有的運行時異常，決不讓這個處理線程退出。隊列裏面出現異常數據了，正常的處理應
該是把異常數據捨棄，然後記錄日誌。不應該由於異常數據而影響下面對正常數據的處理。在這個場景這樣處理可能是
一個比較好的應用，但並不代表在所有的場景你都應該如此。如果在其它場景，遇到了一些錯誤，如果退出程序比較好，
這時你就可以不太理會運行時異常，或者是通過對異常的處理顯式的控制程序退出。
異常和錯誤的區別
異常： 在Java中程序的錯誤主要是語法錯誤和語義錯誤，一個程序在編譯和運行時出現的錯誤我們統一稱之爲異常，它是VM（虛擬機）通知你的一種方式，通過這種 方式，VM讓你知道，你（開發人員）已經犯了個錯誤，現在有一個機會來修改它。Java中使用異常類來表示異常，不同的異常類代表了不同的異常。但是在 Java中所有的異常都有一個基類，叫做Exception。
錯誤：它指的是一個合理的應用程序不能截獲的嚴重的問題。大多數都是反常的情況。”，錯誤是VM的一個故障（雖然它可以是任何系統級的服務）。所以，錯誤是很難處理的，一般的開發人員（當然不是你）是無法處理這些錯誤的。比如內存溢出；
和異常一樣，在Java中用錯誤類來表示錯誤，不同的錯誤類代表了不同的錯誤。
但是在Java中所有的錯誤都有一個基類，叫做Error。
綜上，我們可以知道異常和錯誤最本質的區別就是異常能被開發人員處理而錯誤時系統本來自帶的，一般無法處理也不需要我們程序員來處理。
異常的分類
在Java中異常分爲兩大類：編譯異常和運行異常
運行異常即是RuntimeException；其餘的全部爲編譯異常
JAVA中的異常體系
在Java中異常Exception和錯誤Error有個共同的父類Throwable.
如圖：
三、runtimeException幾個子類的具體介紹
1、 java.lang.ArrayIndexOutOfBoundsException
數組索引越界異常。當對數組的索引值爲負數或大於等於數組大小時拋出。
2、java.lang.ArithmeticException
算術條件異常。譬如：整數除零等。
3、java.lang.NullPointerException
空指針異常。當應用試圖在要求使用對象的地方使用了null時，拋出該異常。譬如：調用null對象的實例方法、訪問null對象的屬性、計算null對象的長度、使用throw語句拋出null等等
4、java.lang.ClassNotFoundException
找不到類異常。當應用試圖根據字符串形式的類名構造類，而在遍歷CLASSPAH之後找不到對應名稱的class文件時，拋出該異常。
二、java中try 與catch的使用
try{
//代碼區
}catch(Exception e){
//異常處理
}
代碼區如果有錯誤，就會返回所寫異常的處理。
首先要清楚，如果沒有try的話，出現異常會導致程序崩潰。
而try則可以保證程序的正常運行下去，比如說：
try{
int i = 1/0;
}catch(Exception e){
........
}
一個計算的話，如果除數爲0，則會報錯，如果沒有try的話，程序直接崩潰。用try的話，則可以讓程序運行下去，並且輸出爲什麼出錯！
try catch 是捕捉try部分的異常，當你沒有trycatch的時候，如果出現異常則程序報錯，加上trycatch，出現異常程序正常運行，只是把錯誤信息存儲到Exception裏，所以catch是用來提取異常信息的，你可以在Catch部分加上一句System.out.println(e.ToString());，如果出現異常可以把異常打印出來
java的異常處理機制(try…catch…finally)
1 引子
try…catch…finally恐怕是大家再熟悉不過的語句了，而且感覺用起來也是很簡單，邏輯上似乎也是很容易理解。不過，我親自體驗的“教訓”告訴我，這個東西可不是想象中的那麼簡單、聽話。不信？那你看看下面的代碼，“猜猜”它執行後的結果會是什麼？不要往後看答案、也不許執行代碼看真正答案哦。如果你的答案是正確，那麼這篇文章你就不用浪費時間看啦。
public class TestException
{
public TestException()
{
}
boolean testEx() throws Exception
{
boolean ret = true;
try
{
ret = testEx1();
}
catch (Exception e)
{
System.out.println("testEx, catch exception");
ret = false;
throw e;
}
finally
{
System.out.println("testEx, finally; return value=" + ret);
return ret;
}
}
boolean testEx1() throws Exception
{
boolean ret = true;
try
{
ret = testEx2();
if (!ret)
{
return false;
}
System.out.println("testEx1, at the end of try");
return ret;
}
catch (Exception e)
{
System.out.println("testEx1, catch exception");
ret = false;
throw e;
}
finally
{
System.out.println("testEx1, finally; return value=" + ret);
return ret;
}
}
boolean testEx2() throws Exception
{
boolean ret = true;
try
{
int b = 12;
int c;
for (int i = 2; i >= -2; i--)
{
c = b / i;
System.out.println("i=" + i);
}
return true;
}
catch (Exception e)
{
System.out.println("testEx2, catch exception");
ret = false;
throw e;
}
finally
{
System.out.println("testEx2, finally; return value=" + ret);
return ret;
}
}
public static void main(String[] args)
{
TestException testException1 = new TestException();
try
{
testException1.testEx();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
你的答案是什麼？是下面的答案嗎？
i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, catch exception
testEx1, finally; return value=false
testEx, catch exception
testEx, finally; return value=false
如果你的答案真的如上面所說，那麼你錯啦。^_^，那就建議你仔細看一看這篇文章或者拿上面的代碼按各種不同的情況修改、執行、測試，你會發現有很多事情不是原來想象中的那麼簡單的。
現在公佈正確答案：
i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, finally; return value=false
testEx, finally; return value=false
2 基礎知識
2.1 相關概念
例外是在程序運行過程中發生的異常事件，比如除0溢出、數組越界、文件找不到等，這些事件的發生將阻止程序的正常運行。爲了加強程序的魯棒性，程序設計時，必須考慮到可能發生的異常事件並做出相應的處理。C語言中，通過使用if語句來判斷是否出現了例外，同時，調用函數通過被調用函數的返回值感知在被調用函數中產生的例外事件並進行處理。全程變量ErroNo常常用來反映一個異常事件的類型。但是，這種錯誤處理機制會導致不少問題。
Java通過面向對象的方法來處理例外。在一個方法的運行過程中，如果發生了例外，則這個方法生成代表該例外的一個對象，並把它交給運行時系統，運行時系統尋找相應的代碼來處理這一例外。我們把生成例外對象並把它提交給運行時系統的過程稱爲拋棄(throw)一個例外。運行時系統在方法的調用棧中查找，從生成例外的方法開始進行回朔，直到找到包含相應例外處理的方法爲止，這一個過程稱爲捕獲(catch)一個例外。
2.2 Throwable類及其子類
用面向對象的方法處理例外，就必須建立類的層次。類 Throwable位於這一類層次的最頂層，只有它的後代纔可以做爲一個例外被拋棄。圖1表示了例外處理的類層次。
從圖中可以看出，類Throwable有兩個直接子類：Error和Exception。Error類對象（如動態連接錯誤等），由Java虛擬機生成並拋棄（通常，Java程序不對這類例外進行處理）；Exception類對象是Java程序處理或拋棄的對象。它有各種不同的子類分別對應於不同類型的例外。其中類RuntimeException代表運行時由Java虛擬機生成的例外，如算術運算例外ArithmeticException(由除0錯等導致)、數組越界例外ArrayIndexOutOfBoundsException等；其它則爲非運行時例外，如輸入輸出例外IOException等。Java編譯器要求Java程序必須捕獲或聲明所有的非運行時例外，但對運行時例外可以不做處理。
2.3 異常處理關鍵字
Java的異常處理是通過5個關鍵字來實現的：try，catch，throw，throws，finally。JB的在線幫助中對這幾個關鍵字是這樣解釋的：
Throws: Lists the exceptions a method could throw.
Throw: Transfers control of the method to the exception handler.
Try： Opening exception-handling statement.
Catch： Captures the exception.
Finally： Runs its code before terminating the program.
2.3.1 try語句
try語句用大括號{}指定了一段代碼，該段代碼可能會拋棄一個或多個例外。
2.3.2 catch語句
catch語句的參數類似於方法的聲明，包括一個例外類型和一個例外對象。例外類型必須爲Throwable類的子類，它指明瞭catch語句所處理的例外類型，例外對象則由運行時系統在try所指定的代碼塊中生成並被捕獲，大括號中包含對象的處理，其中可以調用對象的方法。
catch語句可以有多個，分別處理不同類的例外。Java運行時系統從上到下分別對每個catch語句處理的例外類型進行檢測，直到找到類型相匹配的catch語句爲止。這裏，類型匹配指catch所處理的例外類型與生成的例外對象的類型完全一致或者是它的父類，因此，catch語句的排列順序應該是從特殊到一般。
也可以用一個catch語句處理多個例外類型，這時它的例外類型參數應該是這多個例外類型的父類，程序設計中要根據具體的情況來選擇catch語句的例外處理類型。
2.3.3 finally語句
try所限定的代碼中，當拋棄一個例外時，其後的代碼不會被執行。通過finally語句可以指定一塊代碼。無論try所指定的程序塊中拋棄或不拋棄例外，也無論catch語句的例外類型是否與所拋棄的例外的類型一致，finally所指定的代碼都要被執行，它提供了統一的出口。通常在finally語句中可以進行資源的清除工作。如關閉打開的文件等。
2.3.4 throws語句
throws總是出現在一個函數頭中，用來標明該成員函數可能拋出的各種異常。對大多數Exception子類來說，Java 編譯器會強迫你聲明在一個成員函數中拋出的異常的類型。如果異常的類型是Error或 RuntimeException， 或它們的子類，這個規則不起作用， 因爲這在程序的正常部分中是不期待出現的。 如果你想明確地拋出一個RuntimeException，你必須用throws語句來聲明它的類型。
2.3.5 throw語句
throw總是出現在函數體中，用來拋出一個異常。程序會在throw語句後立即終止，它後面的語句執行不到，然後在包含它的所有try塊中（可能在上層調用函數中）從裏向外尋找含有與其匹配的catch子句的try塊。
3 關鍵字及其中語句流程詳解
3.1 try的嵌套
你可以在一個成員函數調用的外面寫一個try語句，在這個成員函數內部，寫另一個try語句保護其他代碼。每當遇到一個try語句，異常的框架就放到堆棧上面，直到所有的try語句都完成。如果下一級的try語句沒有對某種異常進行處理，堆棧就會展開，直到遇到有處理這種異常的try語句。下面是一個try語句嵌套的例子。
class MultiNest {
static void procedure() {
try {
int a = 0;
int b = 42/a;
} catch(java.lang.ArithmeticException e) {
System.out.println("in procedure, catch ArithmeticException: " + e);
}
}
public static void main(String args[]) {
try {
procedure();
} catch(java.lang. Exception e) {
System.out.println("in main, catch Exception: " + e);
}
}
}
這個例子執行的結果爲：
in procedure, catch ArithmeticException: java.lang.ArithmeticException: / by zero
成員函數procedure裏有自己的try/catch控制，所以main不用去處理 ArrayIndexOutOfBoundsException；當然如果如同最開始我們做測試的例子一樣，在procedure中catch到異常時使用throw e;語句將異常拋出，那麼main當然還是能夠捕捉並處理這個procedure拋出來的異常。例如在procedure函數的catch中的System.out語句後面增加throw e;語句之後，執行結果就變爲：
in procedure, catch ArithmeticException: java.lang.ArithmeticException: / by zero
in main, catch Exception: java.lang.ArithmeticException: / by zero
3.2 try-catch程序塊的執行流程以及執行結果
相對於try-catch-finally程序塊而言，try-catch的執行流程以及執行結果還是比較簡單的。
首先執行的是try語句塊中的語句，這時可能會有以下三種情況：
1．如果try塊中所有語句正常執行完畢，那麼就不會有其他的“動做”被執行，整個try-catch程序塊正常完成。
2．如果try語句塊在執行過程中碰到異常V，這時又分爲兩種情況進行處理：
-->如果異常V能夠被與try相應的catch塊catch到，那麼第一個catch到這個異常的catch塊（也是離try最近的一個與異常V匹配的catch塊）將被執行；如果catch塊執行正常，那麼try-catch程序塊的結果就是“正常完成”；如果該catch塊由於原因R突然中止，那麼try-catch程序塊的結果就是“由於原因R突然中止（completes abruptly）”。
-->如果異常V沒有catch塊與之匹配，那麼這個try-catch程序塊的結果就是“由於拋出異常V而突然中止（completes abruptly）”。
3． 如果try由於其他原因R突然中止（completes abruptly），那麼這個try-catch程序塊的結果就是“由於原因R突然中止（completes abruptly）”。
3.3 try-catch-finally程序塊的執行流程以及執行結果
try-catch-finally程序塊的執行流程以及執行結果比較複雜。
首先執行的是try語句塊中的語句，這時可能會有以下三種情況：
1．如果try塊中所有語句正常執行完畢，那麼finally塊的居於就會被執行，這時分爲以下兩種情況：
-->如果finally塊執行順利，那麼整個try-catch-finally程序塊正常完成。
-->如果finally塊由於原因R突然中止，那麼try-catch-finally程序塊的結局是“由於原因R突然中止（completes abruptly）”
2．如果try語句塊在執行過程中碰到異常V，這時又分爲兩種情況進行處理：
-->如果異常V能夠被與try相應的catch塊catch到，那麼第一個catch到這個異常的catch塊（也是離try最近的一個與異常V匹配的catch塊）將被執行；這時就會有兩種執行結果：
-->如果catch塊執行正常，那麼finally塊將會被執行，這時分爲兩種情況：
-->如果finally塊執行順利，那麼整個try-catch-finally程序塊正常完成。
-->如果finally塊由於原因R突然中止，那麼try-catch-finally程序塊的結局是“由於原因R突然中止（completes abruptly）”
-->如果catch塊由於原因R突然中止，那麼finally模塊將被執行，分爲兩種情況：
-->如果如果finally塊執行順利，那麼整個try-catch-finally程序塊的結局是“由於原因R突然中止（completes abruptly）”。
-->如果finally塊由於原因S突然中止，那麼整個try-catch-finally程序塊的結局是“由於原因S突然中止（completes abruptly）”，原因R將被拋棄。
（注意，這裏就正好和我們的例子相符合，雖然我們在testEx2中使用throw e拋出了異常，但是由於testEx2中有finally塊，而finally塊的執行結果是complete abruptly的（別小看這個用得最多的return，它也是一種導致complete abruptly的原因之一啊——後文中有關於導致complete abruptly的原因分析），所以整個try-catch-finally程序塊的結果是“complete abruptly”，所以在testEx1中調用testEx2時是捕捉不到testEx1中拋出的那個異常的，而只能將finally中的return結果獲取到。
如果在你的代碼中期望通過捕捉被調用的下級函數的異常來給定返回值，那麼一定要注意你所調用的下級函數中的finally語句，它有可能會使你throw出來的異常並不能真正被上級調用函數可見的。當然這種情況是可以避免的，以testEx2爲例：如果你一定要使用finally而且又要將catch中throw的e在testEx1中被捕獲到，那麼你去掉testEx2中的finally中的return就可以了。
這個事情已經在OMC2.0的MIB中出現過啦：服務器的異常不能完全被反饋到客戶端。）
-->如果異常V沒有catch塊與之匹配，那麼finally模塊將被執行，分爲兩種情況：
-->如果finally塊執行順利，那麼整個try-catch-finally程序塊的結局就是“由於拋出異常V而突然中止（completes abruptly）”。
-->如果finally塊由於原因S突然中止，那麼整個try-catch-finally程序塊的結局是“由於原因S突然中止（completes abruptly）”，異常V將被拋棄。
3．如果try由於其他原因R突然中止（completes abruptly），那麼finally塊被執行，分爲兩種情況：
-->如果finally塊執行順利，那麼整個try-catch-finally程序塊的結局是“由於原因R突然中止（completes abruptly）”。
-->如果finally塊由於原因S突然中止，那麼整個try-catch-finally程序塊的結局是“由於原因S突然中止（completes abruptly）”，原因R將被拋棄。
3.4 try-catch-finally程序塊中的return
從上面的try-catch-finally程序塊的執行流程以及執行結果一節中可以看出無論try或catch中發生了什麼情況，finally都是會被執行的，那麼寫在try或者catch中的return語句也就不會真正的從該函數中跳出了，它的作用在這種情況下就變成了將控制權（語句流程）轉到finally塊中；這種情況下一定要注意返回值的處理。
例如，在try或者catch中return false了，而在finally中又return true，那麼這種情況下不要期待你的try或者catch中的return false的返回值false被上級調用函數獲取到，上級調用函數能夠獲取到的只是finally中的返回值，因爲try或者catch中的return語句只是轉移控制權的作用。
3.5 如何拋出異常
如果你知道你寫的某個函數有可能拋出異常，而你又不想在這個函數中對異常進行處理，只是想把它拋出去讓調用這個函數的上級調用函數進行處理，那麼有兩種方式可供選擇：
第一種方式：直接在函數頭中throws SomeException，函數體中不需要try/catch。比如將最開始的例子中的testEx2改爲下面的方式，那麼testEx1就能捕捉到testEx2拋出的異常了。
boolean testEx2() throws Exception{
boolean ret = true;
int b=12;
int c;
for (int i=2;i>=-2;i--){
c=b/i;
System.out.println("i="+i);
}
return true;
}
第二種方式：使用try/catch，在catch中進行一定的處理之後（如果有必要的話）拋出某種異常。例如上面的testEx2改爲下面的方式，testEx1也能捕獲到它拋出的異常：
boolean testEx2() throws Exception{
boolean ret = true;
try{
int b=12;
int c;
for (int i=2;i>=-2;i--){
c=b/i;
System.out.println("i="+i);
}
return true;
}catch (Exception e){
System.out.println("testEx2, catch exception");
Throw e;
}
}
第三種方法：使用try/catch/finally，在catch中進行一定的處理之後（如果有必要的話）拋出某種異常。例如上面的testEx2改爲下面的方式，testEx1也能捕獲到它拋出的異常：
boolean testEx2() throws Exception{
boolean ret = true;
try{
int b=12;
int c;
for (int i=2;i>=-2;i--){
c=b/i;
System.out.println("i="+i);
throw new Exception("aaa");
}
return true;
}catch (java.lang.ArithmeticException e){
System.out.println("testEx2, catch exception");
ret = false;
throw new Exception("aaa");
}finally{
System.out.println("testEx2, finally; return value="+ret);
}
}
4 關於abrupt completion
前面提到了complete abruptly（暫且理解爲“突然中止”或者“異常結束”吧），它主要包含了兩種大的情形：abrupt completion of expressions and statements，下面就分兩種情況進行解釋。
4.1 Normal and Abrupt Completion of Evaluation
每一個表達式（expression）都有一種使得其包含的計算得以一步步進行的正常模式，如果每一步計算都被執行且沒有異常拋出，那麼就稱這個表達式“正常結束（complete normally）”；如果這個表達式的計算拋出了異常，就稱爲“異常結束（complete abruptly）”。異常結束通常有一個相關聯的原因（associated reason），通常也就是拋出一個異常V。
與表達式、操作符相關的運行期異常有：
-->A class instance creation expression, array creation expression , or string concatenation operatior expression throws an OutOfMemoryError if there is insufficient memory available.
-->An array creation expression throws a NegativeArraySizeException if the value of any dimension expression is less than zero.
-->A field access throws a NullPointerException if the value of the object reference expression is null.
-->A method invocation expression that invokes an instance method throws a NullPointerException if the target reference is null.
-->An array access throws a NullPointerException if the value of the array reference expression is null.
-->An array access throws an ArrayIndexOutOfBoundsException if the value of the array index expression is negative or greater than or equal to the length of the array.
-->A cast throws a ClassCastException if a cast is found to be impermissible at run time.
-->An integer division or integer remainder operator throws an ArithmeticException if the value of the right-hand operand expression is zero.
-->An assignment to an array component of reference type throws an ArrayStoreException when the value to be assigned is not compatible with the component type of the array.
4.2 Normal and Abrupt Completion of Statements
正常情況我們就不多說了，在這裏主要是列出了abrupt completion的幾種情況：
-->break, continue, and return 語句將導致控制權的轉換，從而使得statements不能正常地、完整地執行。
-->某些表達式的計算也可能從java虛擬機拋出異常，這些表達式在上一小節中已經總結過了；一個顯式的的throw語句也將導致異常的拋出。拋出異常也是導致控制權的轉換的原因（或者說是阻止statement正常結束的原因）。
如果上述事件發生了，那麼這些statement就有可能使得其正常情況下應該都執行的語句不能完全被執行到，那麼這些statement也就是被稱爲是complete abruptly.
導致abrupt completion的幾種原因：
-->A break with no label
-->A break with a given label
-->A continue with no label
-->A continue with a given label
-->A return with no value
-->A return with a given value A
-->throw with a given value, including exceptions thrown by the Java virtual machine
5 關於我們的編程的一點建議
弄清楚try-catch-finally的執行情況後我們才能正確使用它。
如果我們使用的是try-catch-finally語句塊，而我們又需要保證有異常時能夠拋出異常，那麼在finally語句中就不要使用return語句了（finally語句塊的最重要的作用應該是釋放申請的資源），因爲finally中的return語句會導致我們的throw e被拋棄，在這個try-catch-finally的外面將只能看到finally中的返回值（除非在finally中拋出異常）。（我們需要記住：不僅throw語句是abrupt completion 的原因，return、break、continue等這些看起來很正常的語句也是導致abrupt completion的原因。）