java異常機制

① java異常機制是什麼

一、異常的關鍵字：

一般來說，異常的關鍵字有：try、catch、finally、throw、throws。
網上的資料對這幾個關鍵字是這樣解釋的：
try： Opening exception-handling statement.
catch： Captures the exception.
finally： Runs its code before terminating the program.
throws: Lists the exceptions a method could throw.
Throw: Transfers control of the method to the exception handler.

try語句
try語句用大括弧{}指定了一段代碼，該段代碼可能會拋棄一個或多個例外。
catch語句
catch語句的參數類似於方法的聲明，包括一個例外類型和一個例外對象。例外類型必須為Throwable類的子類，它指明了catch語句所處理的例外類型，例外對象則由運行時系統在try所指定的代碼塊中生成並被捕獲，大括弧中包含對象的處理，其中可以調用對象的方法。
catch語句可以有多個，分別處理不同類的例外。Java運行時系統從上到下分別對每個catch語句處理的例外類型進行檢測，直到找到類型相匹配的catch語句為止。這里，類型匹配指catch所處理的例外類型與生成的例外對象的類型完全一致或者是它的父類，因此，catch語句的排列順序應該是從特殊到一般。也可以用一個catch語句處理多個例外類型，這時它的例外類型參數應該是這多個例外類型的父類，程序設計中要根據具體的情況來選擇catch語句的例外處理類型。
finally語句
try所限定的代碼中，當拋棄一個例外時，其後的代碼不會被執行。通過finally語句可以指定一塊代碼。無論try所指定的程序塊中拋棄或不拋棄例外，也無論catch語句的例外類型是否與所拋棄的例外的類型一致，finally所指定的代碼都要被執行，它提供了統一的出口。通常在finally語句中可以進行資源的清除工作。如關閉打開的文件等。
throws語句
throws總是出現在一個函數頭中，用來標明該成員函數可能拋出的各種異常。對大多數Exception子類來說，Java 編譯器會強迫你聲明在一個成員函數中拋出的異常的類型。如果異常的類型是Error或 RuntimeException， 或它們的子類，這個規則不起作用， 因為這在程序的正常部分中是不期待出現的。 如果你想明確地拋出一個RuntimeException，你必須用throws語句來聲明它的類型
throw語句
throw總是出現在函數體中，用來拋出一個異常。程序會在throw語句後立即終止，它後面的語句執行不到，然後在包含它的所有try塊中（可能在上層調用函數中）從里向外尋找含有與其匹配的catch子句的try塊。

其實，我個人覺得，簡單的來說：throws與throw從拼寫上只相差一個s，但是功能、作用上有很大的區別。throws用於在方法和類處聲明可能拋出的所有異常信息。throw而throw就是單個語句拋出異常，是指拋出的一個具體的異常類型，使用在方法（類）的內部。
如：
………………………………………………………………………………………………………
public class showUI throws Exception(){
public void tbstudy throws Exception(){
****;//
try{
/* 這里是要處理的異常 */
}
Catch(Exception of){
System.out.println(of);//列印出異常
}
}
｝
………………………………………………………………………………………………………
throws通常不用顯示的捕獲異常，可由系統自動將所有捕獲的異常信息拋給上級方法（即調用該方法或類的所有地方）；
throw則需要用戶自己捕獲相關的異常，而後再對其進行相關處理（如列印異常的地方，類型等），最後將處理後的異常信息拋出。
他們對異常處理方式也不同.throws對異常不處理,誰調用誰處理,throws的Exception的取值范圍要大於方法內部異常的最大范圍,而cathch的范圍又要大於throws的Exception的范圍;throw 主動拋出自定義異常類對象。

二、異常繼承體系

異常的繼承結構

三、java處理異常方式
在java代碼中如果發生異常，jvm（java虛擬機）會拋出異常對象，導致程序代碼中斷，這個時候jvm在做的操作就是：創建異常對象，然後拋出，比如：

1．int i= 1；
2．int j = 0；
3．int res = 0；
4．res = i/j；//除0錯誤
5．System.out.println(res);

這5句代碼運行到第四句會中斷，因為jvm拋出了異常

2.throw的作用：手動拋出異常。有時候有些錯誤在jvm看來不是錯誤，比如：
1. int age = 0;
2. age = -100;
3．System.out.println(age);
很正常的整形變數賦值，但是在我們眼中看來就不正常，誰的年齡會是負的呢？！所以我們需要自己手動引發異常，這就是throw的作用
int age = 0;
age = -100;
if(age<0){
Exception e = new Exception(); //創建異常對象
throw e; //拋出異常
}
System.out.println(age);

java中的異常機制

異常機制是指當程序出現錯誤後，程序如何處理。具體來說，異常機制提供了程序退出的安全通道。當出現錯誤後，程序執行的流程發生改變，程序的控制權轉移到異常處理器。
傳統的處理異常的辦法是，函數返回一個特殊的結果來表示出現異常（通常這個特殊結果是大家約定俗稱的），調用該函數的程序負責檢查並分析函數返回的結果。這樣做有如下的弊端：例如函數返回-1代表出現異常，但是如果函數確實要返回-1這個正確的值時就會出現混淆；可讀性降低，將程序代碼與處理異常的代碼混疊在一起；由調用函數的程序來分析錯誤，這就要求客戶程序員對庫函數有很深的了解。

在使用File類的方法時，如正在將U盤裡面的照片復制到電腦里時，有人將U盤拔掉了。這時我們的復製程序就會出錯，即拋出異常。當出現程序無法控制的外部環境問題（用戶提供的文件不存在或者創建文件時已有同名文件存在，文件內容損壞，網路不可用...）時，JAVA就會用異常對象來描述。
異常情況通常有三大類：
(1)檢查性異常:java.lang.Exception
(2)運行期異常:java.lang.RuntimeException
(3)錯誤:java.lang.Error
它們都是java.lang.Throwable類的子孫類。如右圖：
Throwable 類是 Java 語言中所有錯誤和異常類的父類，對於具體的異常，不應該使用Throwable類，而應該使用其他三者之一。
檢查性異常------程序正確，但因為外在的環境條件不滿足引發。例如：用戶錯誤及I/O問題----程序試圖打開一個並不存在的遠程Socket埠。這不是程序本身的邏輯錯誤，而很可能是遠程機器名字錯誤(用戶拼寫錯誤)。對商用軟體系統，程序開發者必須考慮並處理這個問題。JAVA編譯器強制要求處理這類異常，如果不捕獲這類異常，程序將不能被編譯。
運行期異常------這意味著程序存在bug，如數組越界，0被除，入參不滿足規范.....這類異常需要更改程序來避免，JAVA編譯器強制要求處理這類異常。用來表示設計或實現方面的問題，如數組越界等。因為設計和實現正確的程序不會引發這類異常，所以常常不處理它。發生這類異常時，運行時環境會輸出一條信息，提示用戶修正錯誤。
錯誤------一般很少見，也很難通過程序解決。它可能源於程序的bug，但一般更可能源於環境問題，如內存耗盡。錯誤在程序中無須處理，而有運行環境處理。Error表示很難恢復的錯誤，如內存越界。一般不期望用戶程序來處理，即使程序員有能力處理這種錯誤，也還是交給系統處理為好。

② Java中的異常機制有什麼作用

你可以根據出現的異常來進行某些操作,比如一個線程,你不能使用TThread.currentThread().stop();方法停止線程,而你後面可能會有其它操作,如果讓它等到程序運行完畢才停止,那麼這么做就太浪費內存了,這時候你就可以使用Thread.sleep()方法讓線程先中斷,然後使用Thread.currentThread().interrupt();方法讓線程拋出異常,這樣就能達到讓線程停止的操作了,然後你就可以在catch語句塊中執行你後面的操作

③ Java異常機制是什麼

異常指不期而至的各種狀況，如：文件找不到、網路連接失敗、非法參數等。異常是一個事件，它發生在程序運行期間，干擾了正常的指令流程。Java通 過API中Throwable類的眾多子類描述各種不同的異常。因而，Java異常都是對象，是Throwable子類的實例，描述了出現在一段編碼中的 錯誤條件。當條件生成時，錯誤將引發異常。
一、相關知識
1、在 Java 中，所有的異常都有一個共同的祖先 Throwable（可拋出）。Throwable 指定代碼中可用異常傳播機制通過 Java 應用程序傳輸的任何問題的共性。
Throwable： 有兩個重要的子類：Exception（異常）和 Error（錯誤），二者都是 Java 異常處理的重要子類，各自都包含大量子類。
Error（錯誤）:是程序無法處理的錯誤，表示運行應用程序中較嚴重問題。大多數錯誤與代碼編寫者執行的操作無關，而表示代碼運行時 JVM（Java 虛擬機）出現的問題。例如，Java虛擬機運行錯誤（Virtual MachineError），當 JVM 不再有繼續執行操作所需的內存資源時，將出現 OutOfMemoryError。這些異常發生時，Java虛擬機（JVM）一般會選擇線程終止。這些錯誤表示故障發生於虛擬機自身、或者發生在虛擬機試圖執行應用時，如Java虛擬機運行錯誤（Virtual MachineError）、類定義錯誤（NoClassDefFoundError）等。這些錯誤是不可查的，因為它們在應用程序的控制和處理能力之 外，而且絕大多數是程序運行時不允許出現的狀況。對於設計合理的應用程序來說，即使確實發生了錯誤，本質上也不應該試圖去處理它所引起的異常狀況。在 Java中，錯誤通過Error的子類描述。
Exception（異常）:是程序本身可以處理的異常。Exception 類有一個重要的子類 RuntimeException。RuntimeException 類及其子類表示「JVM 常用操作」引發的錯誤。例如，若試圖使用空值對象引用、除數為零或數組越界，則分別引發運行時異常（NullPointerException、ArithmeticException）和 ArrayIndexOutOfBoundException。
注意：異常和錯誤的區別：異常能被程序本身可以處理，錯誤是無法處理。
2、通常，Java的異常(包括Exception和Error)分為可查的異常（checked exceptions）和不可查的異常（unchecked exceptions）。
可查異常（編譯器要求必須處置的異常）：正確的程序在運行中，很容易出現的、情理可容的異常狀況。可查異常雖然是異常狀況，但在一定程度上它的發生是可以預計的，而且一旦發生這種異常狀況，就必須採取某種方式進行處理。除了RuntimeException及其子類以外，其他的Exception類及其子類都屬於可查異常。這種異常的特點是Java編譯器會檢查它，也就是說，當程序中可能出現這類異常，要麼用try-catch語句捕獲它，要麼用throws子句聲明拋出它，否則編譯不會通過。
不可查異常(編譯器不要求強制處置的異常):包括運行時異常（RuntimeException與其子類）和錯誤（Error）。
3、Exception 這種異常分兩大類運行時異常和非運行時異常(編譯異常)。程序中應當盡可能去處理這些異常。
運行時異常：都是RuntimeException類及其子類異常，如NullPointerException(空指針異常)、IndexOutOfBoundsException(下標越界異常)等，這些異常是不檢查異常，程序中可以選擇捕獲處理，也可以不處理。這些異常一般是由程序邏輯錯誤引起的，程序應該從邏輯角度盡可能避免這類異常的發生。運行時異常的特點是Java編譯器不會檢查它，也就是說，當程序中可能出現這類異常，即使沒有用try-catch語句捕獲它，也沒有用throws子句聲明拋出它，也會編譯通過。
非運行時異常 （編譯異常）：是RuntimeException以外的異常，類型上都屬於Exception類及其子類。從程序語法角度講是必須進行處理的異常，如果不處理，程序就不能編譯通過。如IOException、SQLException等以及用戶自定義的Exception異常，一般情況下不自定義檢查異常。
二、處理機制
在 Java 應用程序中，異常處理機制為：拋出異常，捕捉異常。
拋出異常：當一個方法出現錯誤引發異常時，方法創建異常對象並交付運行時系統，異常對象中包含了異常類型和異常出現時的程序狀態等異常信息。運行時系統負責尋找處置異常的代碼並執行。
捕獲異常：在方法拋出異常之後，運行時系統將轉為尋找合適的異常處理器（exception handler）。潛在的異常處理器是異常發生時依次存留在調用棧中的方法的集合。當異常處理器所能處理的異常類型與方法拋出的異常類型相符時，即為合適 的異常處理器。運行時系統從發生異常的方法開始，依次回查調用棧中的方法，直至找到含有合適異常處理器的方法並執行。當運行時系統遍歷調用棧而未找到合適 的異常處理器，則運行時系統終止。同時，意味著Java程序的終止。
對於運行時異常、錯誤或可查異常，Java技術所要求的異常處理方式有所不同。
由於運行時異常的不可查性，為了更合理、更容易地實現應用程序，Java規定，運行時異常將由Java運行時系統自動拋出，允許應用程序忽略運行時異常。
對於方法運行中可能出現的Error，當運行方法不欲捕捉時，Java允許該方法不做任何拋出聲明。因為，大多數Error異常屬於永遠不能被允許發生的狀況，也屬於合理的應用程序不該捕捉的異常。
對於所有的可查異常，Java規定：一個方法必須捕捉，或者聲明拋出方法之外。也就是說，當一個方法選擇不捕捉可查異常時，它必須聲明將拋出異常。
能夠捕捉異常的方法，需要提供相符類型的異常處理器。所捕捉的異常，可能是由於自身語句所引發並拋出的異常，也可能是由某個調用的方法或者Java運行時 系統等拋出的異常。也就是說，一個方法所能捕捉的異常，一定是Java代碼在某處所拋出的異常。簡單地說，異常總是先被拋出，後被捕捉的。
任何Java代碼都可以拋出異常，如：自己編寫的代碼、來自Java開發環境包中代碼，或者Java運行時系統。無論是誰，都可以通過Java的throw語句拋出異常。
從方法中拋出的任何異常都必須使用throws子句。
捕捉異常通過try-catch語句或者try-catch-finally語句實現。
總體來說，Java規定：對於可查異常必須捕捉、或者聲明拋出。允許忽略不可查的RuntimeException和Error。

④ JAVA中的異常處理機制的原理

對於可能出現異常的代碼，有兩種處理辦法：
第一、在方法中用try...catch語句捕獲並處理異常，catach語句可以有多個，用來匹配多個異常。例如：
public void p(int x){
try{
...
}catch(Exception e){
...
}finally{
...
}
}

第二、對於處理不了的異常或者要轉型的異常，在方法的聲明處通過throws語句拋出異常。例如：
public void test1() throws MyException{
...
if(....){
throw new MyException();
}
}
如果每個方法都是簡單的拋出異常，那麼在方法調用方法的多層嵌套調用中，Java虛擬機會從出現異常的方法代碼塊中往回找，直到找到處理該異常的代碼塊為止。然後將異常交給相應的catch語句處理。如果Java虛擬機追溯到方法調用棧最底部main()方法時，如果仍然沒有找到處理異常的代碼塊，將按照下面的步驟處理：
第一、調用異常的對象的printStackTrace()方法，列印方法調用棧的異常信息。
第二、如果出現異常的線程為主線程，則整個程序運行終止；如果非主線程，則終止該線程，其他線程繼續運行。
通過分析思考可以看出，越早處理異常消耗的資源和時間越小，產生影響的范圍也越小。因此，不要把自己能處理的異常也拋給調用者。
還有一點，不可忽視：finally語句在任何情況下都必須執行的代碼，這樣可以保證一些在任何情況下都必須執行代碼的可靠性。比如，在資料庫查詢異常的時候，應該釋放JDBC連接等等。finally語句先於return語句執行，而不論其先後位置，也不管是否try塊出現異常。finally 語句唯一不被執行的情況是方法執行了System.exit()方法。System.exit()的作用是終止當前正在運行的 Java 虛擬機。finally語句塊中不能通過給變數賦新值來改變return的返回值，也建議不要在finally塊中使用return語句，沒有意義還容易導致錯誤。

最後還應該注意一下異常處理的語法規則：
第一、try語句不能單獨存在，可以和catch、finally組成 try...catch...finally、try...catch、try...finally三種結構，catch語句可以有一個或多個，finally語句最多一個，try、catch、finally這三個關鍵字均不能單獨使用。
第二、try、catch、finally三個代碼塊中變數的作用域分別獨立而不能相互訪問。如果要在三個塊中都可以訪問，則需要將變數定義到這些塊的外面。
第三、多個catch塊時候，Java虛擬機會匹配其中一個異常類或其子類，就執行這個catch塊，而不會再執行別的catch塊。
第四、throw語句後不允許有緊跟其他語句，因為這些沒有機會執行。
第五、如果一個方法調用了另外一個聲明拋出異常的方法，那麼這個方法要麼處理異常，要麼聲明拋出。

那怎麼判斷一個方法可能會出現異常呢？一般來說，方法聲明的時候用了throws語句，方法中有throw語句，方法調用的方法聲明有throws關鍵字。

⑤ Java中異常處理機制有哪些

1.try和catch語句

●將要處理的代碼放入try塊中，然後創建相應的catch塊的列表。如果生成都異常與catch中提到的相匹配，那麼catch條件中的塊語句就被執行。try塊後可能有許多catch塊，每個都處理不同的異常。每個catch中的參數都是Exception的子類。

2.finally語句

●finally語句定義一個總是執行的代碼，而不考慮異常是否被捕獲。
3.throw引起一個異常

‍●‍‍調用申明拋出異常

public class Test{

static void MethodA() throws {

int a[] = {1, 2, 3};

for (int i = 0; i < 4; i++) {

System.out.println(a[i]);

}

}

public static void main(String args[]){

try {

MethodA();

} catch ( e) {

System.out.println(e);

}

}

}

●‍throw語句強制拋出異常

public class Test{

public static void main(String args[]){

try {

throw new ();

} catch ( e) {

System.out.println(e);

}

}

}

⑥ 在java中，異常處理的機制有哪幾種，分別是什麼

1 引子
try…catch…finally恐怕是大家再熟悉不過的語句了，而且感覺用起來也是很簡單，邏輯上似乎也是很容易理解。不過，我親自體驗的「教訓」告訴我，這個東西可不是想像中的那麼簡單、聽話。不信？那你看看下面的代碼，「猜猜」它執行後的結果會是什麼？不要往後看答案、也不許執行代碼看真正答案哦。如果你的答案是正確，那麼這篇文章你就不用浪費時間看啦。

package myExample.testException;

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錯等導致)、數組越界例外等；其它則為非運行時例外，如輸入輸出例外IOException等。Java編譯器要求Java程序必須捕獲或聲明所有的非運行時例外，但對運行時例外可以不做處理。

圖1 例外處理的類層次

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 procere() {

try {

int a = 0;

int b = 42/a;

} catch(java.lang.ArithmeticException e) {

System.out.println("in procere, catch ArithmeticException: " + e);

}

}

public static void main(String args[]) {

try {

procere();

} catch(java.lang. Exception e) {

System.out.println("in main, catch Exception: " + e);

}

}

}

這個例子執行的結果為：

in procere, catch ArithmeticException: java.lang.ArithmeticException: / by zero

成員函數procere里有自己的try/catch控制，所以main不用去處理 ；當然如果如同最開始我們做測試的例子一樣，在procere中catch到異常時使用throw e;語句將異常拋出，那麼main當然還是能夠捕捉並處理這個procere拋出來的異常。例如在procere函數的catch中的System.out語句後面增加throw e;語句之後，執行結果就變為：

in procere, 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 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的原因。）

⑦ 簡述Java中異常處理的機制

有兩中方式:1.捕獲異常,自己處理.
2.throw出去,讓別人處理.
舉個例子:
public class A{
try{
可能發生異常的語句...

}catch(Exception e){
e.getMessage();//自己處理
}

}

public class A throws Exception{

可能發生異常的語句...

}//throw出去,讓別人處理
注意這里用的是throws
如果在方法裡面則用throw
舉例:
public class A{
try{
可能放生異常的語句...

}catch(Exception e){
e.getMessage();//自己處理
throw new Exception ("");
}

}

⑧ java中輸出和輸入的異常機制是什麼

本文重在Java中異常機制的一些概念。寫本文的目的在於方便我很長時間後若是忘了這些東西可以通過這片文章迅速回憶起來。
1. 異常機制
1.1
異常機制是指當程序出現錯誤後，程序如何處理。具體來說，異常機制提供了程序退出的安全通道。當出現錯誤後，程序執行的流程發生改變，程序的控制權轉移到異常處理器。
1.2
傳統的處理異常的辦法是，函數返回一個特殊的結果來表示出現異常（通常這個特殊結果是大家約定俗稱的），調用該函數的程序負責檢查並分析函數返回的結果。這樣做有如下的弊端：例如函數返回-1代表出現異常，但是如果函數確實要返回-1這個正確的值時就會出現混淆；可讀性降低，將程序代碼與處理異常的代碼混爹在一起；由調用函數的程序來分析錯誤，這就要求客戶程序員對庫函數有很深的了解。
1.3 異常處理的流程
1.3.1 遇到錯誤，方法立即結束，並不返回一個值；同時，拋出一個異常對象
1.3.2 調用該方法的程序也不會繼續執行下去，而是搜索一個可以處理該異常的異常處理器，並執行其中的代碼

2 異常的分類
2.1 異常的分類
2.1.1
異常的繼承結構：基類為Throwable，Error和Exception繼承Throwable，RuntimeException和IOException等繼承Exception，具體的RuntimeException繼承RuntimeException。
2.1.2
Error和RuntimeException及其子類成為未檢查異常（unchecked），其它異常成為已檢查異常（checked）。
2.2 每個類型的異常的特點
2.2.1 Error體系
Error類體系描述了Java運行系統中的內部錯誤以及資源耗盡的情形。應用程序不應該拋出這種類型的對象（一般是由虛擬機拋出）。如果出現這種錯誤，除了盡力使程序安全退出外，在其他方面是無能為力的。所以，在進行程序設計時，應該更關注Exception體系。
2.2.2 Exception體系
Exception體系包括RuntimeException體系和其他非RuntimeException的體系
2.2.2.1 RuntimeException
RuntimeException體系包括錯誤的類型轉換、數組越界訪問和試圖訪問空指針等等。處理RuntimeException的原則是：如果出現RuntimeException，那麼一定是程序員的錯誤。例如，可以通過檢查數組下標和數組邊界來避免數組越界訪問異常。
2.2.2.2 其他（IOException等等）
這類異常一般是外部錯誤，例如試圖從文件尾後讀取數據等，這並不是程序本身的錯誤，而是在應用環境中出現的外部錯誤。
2.3 與C++異常分類的不同
2.3.1
其實，Java中RuntimeException這個類名起的並不恰當，因為任何異常都是運行時出現的。（在編譯時出現的錯誤並不是異常，換句話說，異常就是為了解決程序運行時出現的的錯誤）。
2.3.2
C++中logic_error與Java中的RuntimeException是等價的，而runtime_error與Java中非RuntimeException類型的異常是等價的。
3 異常的使用方法

3.1 聲明方法拋出異常
3.1.1 語法：throws（略）
3.1.2 為什麼要聲明方法拋出異常？
方法是否拋出異常與方法返回值的類型一樣重要。假設方法拋出異常確沒有聲明該方法將拋出異常，那麼客戶程序員可以調用這個方法而且不用編寫處理異常的代碼。那麼，一旦出現異常，那麼這個異常就沒有合適的異常控制器來解決。
3.1.3 為什麼拋出的異常一定是已檢查異常？
RuntimeException與Error可以在任何代碼中產生，它們不需要由程序員顯示的拋出，一旦出現錯誤，那麼相應的異常會被自動拋出。而已檢查異常是由程序員拋出的，這分為兩種情況：客戶程序員調用會拋出異常的庫函數（庫函數的異常由庫程序員拋出）；客戶程序員自己使用throw語句拋出異常。遇到Error，程序員一般是無能為力的；遇到RuntimeException，那麼一定是程序存在邏輯錯誤，要對程序進行修改（相當於調試的一種方法）；只有已檢查異常才是程序員所關心的，程序應該且僅應該拋出或處理已檢查異常。
3.1.4
注意：覆蓋父類某方法的子類方法不能拋出比父類方法更多的異常，所以，有時設計父類的方法時會聲明拋出異常，但實際的實現方法的代碼卻並不拋出異常，這樣做的目的就是為了方便子類方法覆蓋父類方法時可以拋出異常。
3.2 如何拋出異常
3.2.1 語法：throw（略）
3.2.2 拋出什麼異常？
對於一個異常對象，真正有用的信息時異常的對象類型，而異常對象本身毫無意義。比如一個異常對象的類型是ClassCastException，那麼這個類名就是唯一有用的信息。所以，在選擇拋出什麼異常時，最關鍵的就是選擇異常的類名能夠明確說明異常情況的類。
3.2.3
異常對象通常有兩種構造函數：一種是無參數的構造函數；另一種是帶一個字元串的構造函數，這個字元串將作為這個異常對象除了類型名以外的額外說明。
3.2.4
創建自己的異常：當Java內置的異常都不能明確的說明異常情況的時候，需要創建自己的異常。需要注意的是，唯一有用的就是類型名這個信息，所以不要在異常類的設計上花費精力。
3.3 捕獲異常
如果一個異常沒有被處理，那麼，對於一個非圖形界面的程序而言，該程序會被中止並輸出異常信息；對於一個圖形界面程序，也會輸出異常的信息，但是程序並不中止，而是返回用Ы緱媧�硌�分小?BR> 3.3.1 語法：try、catch和finally（略）
控制器模塊必須緊接在try塊後面。若擲出一個異常，異常控制機制會搜尋參數與異常類型相符的第一個控制器隨後它會進入那個catch
從句，並認為異常已得到控制。一旦catch 從句結束對控制器的搜索也會停止。
3.3.1.1 捕獲多個異常（注意語法與捕獲的順序）（略）
3.3.1.2 finally的用法與異常處理流程（略）
3.3.2 異常處理做什麼？
對於Java來說，由於有了垃圾收集，所以異常處理並不需要回收內存。但是依然有一些資源需要程序員來收集，比如文件、網路連接和圖片等資源。
3.3.3 應該聲明方法拋出異常還是在方法中捕獲異常？
原則：捕捉並處理哪些知道如何處理的異常，而傳遞哪些不知道如何處理的異常
3.3.4 再次拋出異常
3.3.4.1 為什麼要再次拋出異常？
在本級中，只能處理一部分內容，有些處理需要在更高一級的環境中完成，所以應該再次拋出異常。這樣可以使每級的異常處理器處理它能夠處理的異常。
3.3.4.2 異常處理流程
對應與同一try塊的catch塊將被忽略，拋出的異常將進入更高的一級。
4 關於異常的其他問題
4.1 過度使用異常
首先，使用異常很方便，所以程序員一般不再願意編寫處理錯誤的代碼，而僅僅是簡簡單單的拋出一個異常。這樣做是不對的，對於完全已知的錯誤，應該編寫處理這種錯誤的代碼，增加程序的魯棒性。另外，異常機制的效率很差。
4.2 將異常與普通錯誤區分開
對於普通的完全一致的錯誤，應該編寫處理這種錯誤的代碼，增加程序的魯棒性。只有外部的不能確定和預知的運行時錯誤才需要使用異常。
4.3 異常對象中包含的信息
一般情況下，異常對象唯一有用的信息就是類型信息。但使用異常帶字元串的構造函數時，這個字元串還可以作為額外的信息。調用異常對象的getMessage()、toString()或者printStackTrace()方法可以分別得到異常對象的額外信息、類名和調用堆棧的信息。並且後一種包含的信息是前一種的超集。

關於Java異常處理的throws

⑨ Java中的異常處理機制的簡單原理和應用。

Java中的異常處理機制的簡單原理和應用 :

java中Throwable這個類可以被作為異常拋出的類,繼承它的分為異常Exception和錯誤Error.

Exception表示程序需要捕捉和處理的的異常;

Error表示系統級別的錯誤和程序無需處理的。

我們所需要關心的是Exception. Execption可以分為java標準定義的異常和程序員自定義異常2種.

（1）一種是當程序違反了java語規則的時候,JAVA虛擬機就會將發生的錯誤表示為一個異常.這里語法規則指的是JAVA類庫內置的語義檢查。

（2）另一種情況就是JAVA允許程序員擴展這種語義檢查，程序員可以創建自己的異常，並自由選擇在何時用throw關鍵字引發異常。所有的異常都是Thowable的子類。

異常處理是與程序執行是並行的.

Try{

//可能發現異常的語句塊

}catch(異常類型,e){

//發生異常時候的執行語句塊

}finnally{

//不管是否發生異常都執行的語句塊

}

以下是一個自定義異常測試類:

packagecode;

{
publicvoidf()
{
System.out.println("thisismyException!!");
}
}
publicclassExceptionTestTwo{
privateinti=0;
privateintj;
ExceptionTestTwo(intx)throwsMyException
{
f2();
j=x/i;
}
publicvoidf2()throwsMyException
{
System.out.println("thisisMyfirstException!!");
thrownewMyException();
}
publicstaticvoidmain(String[]args)
{
try{
newExceptionTestTwo(9);
}catch(MyExceptione2){
e2.f();
}catch(Exceptione){
e.printStackTrace();
}finally{
System.out.println("FinallyisfirstException!!");
}
try{
thrownewMyException();
}catch(MyExceptione1){
e1.f();
}finally{
System.out.println("FinallyissecondException!!");
}
}
}

⑩ 北大青鳥java培訓：Java中異常與錯誤的處理方法

Java中的異常處理機制已經比較成熟，我們的Java程序到處充滿了異常的可能，如果對這些異常不做預先的處理，那麼將來程序崩潰就無從調試，很難找到異常所在的位置。
河北電腦培訓http://www.kmbdqn.cn/將探討一下Java中異常與錯誤的處理方法，一起來看看。
異常與錯誤：異常：在Java中程序的錯誤主要是語法錯誤和語義錯誤，一個程序在編譯和運行時出現的錯誤我們統一稱之為異常，它是VM(虛擬機)通知你的一種方式，通過這種方式，VM讓你知道，你(開發人員)已經犯了個錯誤，現在有一個機會來修改它。
Java中使用異常類來表示異常，不同的異常類代表了不同的異常。
但是在Java中所有的異常都有一個基類，叫做Exception。
錯誤：它指的是一個合理的應用程序不能截獲的嚴重的問題。
大多數都是反常的情況。
錯誤是VM的一個故障(雖然它可以是任何系統級的服務)。
所以，錯誤是很難處理的，一般的開發人員(當然不是你)是無法處理這些錯誤的，比如內存溢出。
和異常一樣，在Java中用錯誤類來表示錯誤，不同的錯誤類代表了不同的錯誤。
但是在Java中所有的錯誤都有一個基類，叫做Error。
綜上，我們可以知道異常和錯誤最本質的區別就是異常能被開發人員處理而錯誤時系統本來自帶的，一般無法處理也不需要我們程序員來處理。
1.一個異常是在一個程序執行過程中出現的一個事件，它中斷了正常指令的運行2.錯誤，偏離了可接受的代碼行為的一個動作或實例異常的結構分類：1、運行時異常(未檢查異常)2、編譯時異常(已檢查異常)運行異常即是RuntimeException;其餘的全部為編譯異常在Java中異常Exception和錯誤Error有個共同的父類Throwable。
幾個子類1、java.lang.數組索引越界異常。
當對數組的索引值為負數或大於等於數組大小時拋出。
2、java.lang.ArithmeticException算術條件異常。
譬如：整數除零等。
3、java.lang.NullPointerException空指針異常。
當應用試圖在要求使用對象的地方使用了null時，拋出該異常。
譬如：調用null對象的實例方法、訪問null對象的屬性、計算null對象的長度、使用throw語句拋出null等等4、java.lang.ClassNotFoundException找不到類異常。
當應用試圖根據字元串形式的類名構造類，而在遍歷CLASSPAH之後找不到對應名稱的class文件時，拋出該異常。