java異常的總結

標籤：

1、異常概述：
什麼是異常？
異常是一個類，用來描述程式運行時出現的不正常現象。
異常的由來：
異常源於現實生活中對於問題的描述，現實生活中的問題也是事物，問題也具有眾多屬性和行為，比如問題名稱、
問題資訊、問題原因、問題情況等。所以問題也可以被描述，並封裝成對象。而現實生活中具有很多很多具體的問題，
這些問題有共性之處，也有不同之處，所以向上抽取，就會形成一個體系。
JAVA中用這樣的一個體系來描述現實生活中問題的體系：
Object
|--Throwable
|---Error
|----OutOfMemoryError,..Error,...
|---Exception
|----RuntimeException,...
|-----IndexOutofBoundsException,NullPointerException,AritchmeticException,...
|------ArrayIndexOutofBoundsException,...

總體來講：Trowable是祖先，下面分為兩大派系：Error和Exception
Error:用來描述嚴重問題，所謂嚴重問題，就是不需要針對性處理的問題，因為非常嚴重，所以直接將
程式停掉，不要再繼續執行就是對其的一般處理方式，並不需要將問題針對想處理完後，再繼續運
行程式。
Exception:用來描述非嚴重問題，這類問題一般需要進行針對性處理，即程式員需要在程式中用代碼處理，
如果交給JVM處理的話，JVM會直接停掉程式，然後將異常對象（即對出現的問題進行封裝成的對象）拋出。
處理的一般格式是：
try{可能出現問題，即拋出異常對象的程式碼片段}
catch(異常類 變數名){對()內指定的異常進行針對性的處理}
finally{不管拋出異常與否，都需要執行的部分}
注意：Exception和Error類都有很多子類，這些子類在命名時，JAVA都會使得其名稱最後一部分是父類的
名稱，即要麼是Exception,要麼是Error。

在學習這個體系的時候，需要查看JAVA API協助文檔，學習使用的原則是：查看父類定義，建立子類對象。

注意：程式中的異常是在程式運行時才會產生的，且異常產生的形式是產生異常對象，而異常對象的產生
有兩種，一種是自動產生，一種是手動產生，手動產生為 "throw new 異常類名();"，與產生普通類
對象一樣，只是需要用關鍵字throw手動拋出。
而一旦拋出了異常對象後，程式就會發生跳轉，即不再執行拋出異常對象語句以下的其他代碼，跳轉
到上一個調用者，並同時將異常對象拋給上一個調用者。若上層調用者沒有相應的對其處理則繼續拋出
到上一個調用者，直至拋到最上層的調用者JVM，JVM會對拋出的異常進行預設處理，即調用其內的預設
異常處理機制進行預設處理（實際上就是列印該異常對象的堆疊追蹤資訊，即e.printStackTrace()。
）。然後結束整個程式。
通常對於被調用者拋給調用者的異常對象，調用者有兩種方式進行處理，一種是不處理，繼續向
上層調用者拋出，另一種是用try...catch語句處理。

2、try-catch:try..catch..它們是一個整體。可以沒有finally塊。
try{可能出現問題，即拋出異常對象的程式碼片段}
catch(異常類 變數名){對()內指定的異常進行針對性的處理}
finally{不管拋出異常與否，都需要執行的部分}
try代碼塊用於檢測是否有異常對象拋出，catch用於捕捉拋出的異常對象。
可以有多個catch代碼塊，當有多個catch代碼塊時，會依次匹配()中的異常類引用，看是否能將拋出的異常對象
轉換成()中所示的異常類類型，即 “異常對象 instanceof 異常類”，如果該異常對象（暫時記為 ex ）若能
賦給catch括弧()中的 e ，則就執行catch大括弧{}中的代碼，執行完後，繼續執行try..catch..finally中的
finally{}中的語句，執行完後，就繼續執行下面的代碼。其他的catch塊就不再執行。如果不能賦給e，則繼續
嘗試賦值給下一個catch塊中的e，直到匹配正確或匹配結束，如果匹配結束仍沒有匹配到合適的e，則會預設
繼續向上層拋出。
當出現自動拋出的異常對象後，如果沒有相應處理，則該異常會拋到上一層調用者，上一層調用者沒有處理或者
沒能用catch捕獲該異常，則該異常會繼續拋到上一層調用者，直到被JVM處理，這種情況，程式就會發生連續跳轉。

try
{
int a=3,b=0;
int x = a/b;
System.out.println("x = "+x);
}
catch(ArithmeticException e)
{
System.out.println(e.toString())
}
catch(NullPointerException e)
{
System.out.println(e.toString())
}
finally
{
}
注意：如果沒有異常拋出，try塊中沒有異常對象出現，則就正常執行try塊中的語句，不執行catch塊中的
語句，如果有finally塊，則執行finally塊，然後繼續執行其他語句。

3、異常聲明throws：
異常聲明：異常聲明是指一個方法，對於自身的函數語句是否會產生異常並不確定，這時候，就可以在方法頭的後面
用關鍵字throws聲明可能產生的異常對象的類型（即其所屬的類）。

目的：使用異常聲明是為了告訴調用者，本函數可能會因為某些原因拋出一些異常，調用者需要做好準備有相應的
處理措施（要麼繼續拋出異常，即調用者也在函數頭聲明異常，要麼使用try..catch..語句處理異常）。
而一旦一個方法進行了異常聲明後，則其調用者必須用try..catch..處理可能被拋出的異常對象（即用try塊檢測
可能拋出異常的這個方法的調用部分），或者繼續向上拋出異常（即也進行異常聲明）。

特殊情況：當一個函數內進行了手動拋出異常對象，即throw new 異常類(); ，則就需要將該函數進行該異常類
聲明，即用throws 異常類，放在函數的()和{}之間的位置上。這是強制的，否則編譯會報錯。這種情況，只
針對“編譯時間異常”有約束作用，對於“運行時異常”（即RuntimeException及其子類）沒有約束作用，在7中會
詳述。
eg.
class B
{
public void method(int a,int b) throws XXException,YYException
{
if(b == 1)
throw new XXException();
if(a < b)
throw new YYException;
return a*b;
}
}
class A
{
public static void main()
{
B b = new B();
try//定義在其中的變數時局部變數，只在try代碼塊中有效。所以要注意變數的範圍。
{
int x =b.method(3,1);
System.out.println(x);
}
catch(XXException e)//這裡的定義類似於函數，e是一個局部變數，只在該catch塊中有效。
{
System.out.println(XX);
}
catch(YYException e) //這些代碼塊中可以有各種語句，定義很多東西，內部類，變數，對象都行。
{
System.out.println(YY);
}
System.out.println("over!");
}
}

4、多異常處理：當一個try塊對應多個catch塊時，即有多個異常對象要處理時，異常對象應按照下面的規則進行處理：
父類的異常對象要放在子類的異常對象的下面。否則編譯會報錯，因為子類異常對象處理代碼時永遠也
執行不到的。
同時一個方法可以拋出多個異常對象，但是一次只能拋出一個異常對象，不會同時拋出兩個異常對象
的，該方法可以進行多個異常類的聲明，用逗號隔開，即throws XXException,YYException,ZZException
5、自訂異常：
自訂異常需求：當項目中出現需要本項目特有的問題時，JAVA中沒有對其進行描述過，所以需要自己對該
問題進行描述，這是就需要自訂自己的異常類。
自訂異常：一個類需要加入到JAVA異常體系中，才能成為自訂異常類。一般通過繼承Exception類或者
RuntimeException類來完成。這個自訂的異常類中可以覆寫父類中的方法，也可以定義自己特有的資料和
成員。
對於是繼承Exception還是RuntimeException呢？
如果自訂異常類是編譯時間異常，則繼承Exception類。
如果自訂異常類是運行時異常，則繼承RuntimeException類。
如何判斷自訂異常類是不是編譯時間異常，請看7。
6、throw和throws的區別：
throws關鍵字用在函數上，用來進行異常類聲明。其後面跟著的是異常類名稱，可以跟多個，用逗號分隔
throw關鍵字用在函數內，用來拋出異常對象。其後面跟的是一個異常類對象，只能一個。

7、RuntimeException:
什麼是運行時異常和編譯時間異常？
異常分為兩種，一種是編譯時間異常，一種是運行時異常。
編譯時間異常是編譯時間檢測的異常，該種異常是指該異常對象出現時，並不會完全影響到運算，處理完該
異常後，仍然可以繼續運行程式的。

運行時異常是編譯時間不檢測的異常，該種異常是指該異常對象出現時，代表者不能進行運算了，所以該
異常對象代表運算不能進行了，所以其後面的哪些可能基於該運算的語句都不應該繼續運行下去了。
整個程式也不應該繼續運行下去了，應當對代碼進行修正，已達到可以正確運算的目的。所以當出現
該異常時，JVM希望程式終止，不要再運行下去了，如果對該類異常處理後，使得程式繼續運行下去
就相當於隱藏了情況，使得我們無法知道程式出現的是什麼問題，如果是運算問題，就應該停止執行
，修正代碼。比如null 指標異常（NullPointerException）、算數異常（ArithmeticException）除數為
0。說明調用方式出現了問題，並沒有正確提供正確運算的參數，需要修正代碼。

編譯時間異常，是在程式中出現該異常時，可以針對性處理後，程式仍繼續執行。
運行時異常，是在程式中出現該異常時，希望不對該異常進行處理，希望程式要停止，使得程式員發現問題，
並進行代碼修改。

所以：如果在函數內有拋出編譯時間異常對象，則函數上必須進行該異常類的聲明。否則編譯出錯，而且
調用者必須由相應的處理操作（繼續拋出或者try處理），否則編譯出錯。
如果在函數內有拋出運行時異常對象，則函數上不必進行該異常類的聲明（聲明編譯也是對的，但一般
不聲明），調用者也不必進行處理操作（操作也是對的，但一般不操作），編譯一樣會通過。而運行時
異常類就是指RuntimeException及其子類。

*/

 

class Demo
{
int x =0;
int div(int a,int b)
{
int[] arr = new int[5];
System.out.println(arr[a]);
return a/b;
}
void Print(String str)throws ArithmeticException,NullPointerException
{
try
{
if(str.equals("wanglinlin"))
{
String info = "Failure!沒有捕獲到--div--拋出的異常";
try
{
System.out.println(str+div(4,0));
}
catch (ArithmeticException e)
{
info ="Success!成功捕獲到--div--拋出的異常";
System.out.println(e.getMessage());
}
finally
{
System.out.println("Print Finally:"+info);
}

}
}
catch (NullPointerException e)
{
System.out.println(e.getMessage());
}

}
}

 

class ExceptionDemo
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x=d.div(4,1);
System.out.println("x ="+x);
}
catch (NullPointerException e)//此處相當於多態 Exception e = new ArithmeticException();
{
System.out.println("除數為0");
System.out.println(e.toString());//該語句和System.out.println(e)一樣，列印一個對象，系統會自動調用
//toString()來輸出該對象的字串表現形式。
}
finally//無論是否拋出異常，以及異常是否被catch塊捕捉到，都會執行的finally代碼塊。
{
System.out.println("finally!");
}
System.out.println("over!");//只有沒有出現異常，正確執行時和出現異常並異常被catch代碼塊捕獲時，才會
//執行該語句，當出現異常，而catch代碼塊沒有捕捉到異常時，不會執行該語句。
//會在執行完finally語句後，直接向上層調用者跳轉，並將異常拋給上層調用者。
}
}

java異常的總結