try-catch和throw,throws的區別和聯絡

區別一：throw 是語句拋出一個異常；throws 是方法拋出一個異常；

throw文法：throw <異常對象>

在方法聲明中，添加throws子句表示該方法將拋出異常。如果一個方法會有異常，但你並不想處理這個異常，就在方法名後面用throws,這樣這個異常就會拋出，誰調用了這個方法誰就要處理這個異常，或者繼續拋出.

throws文法：[<修飾符>]<傳回值類型><方法名>（[<參數列表>]）[throws<異常類>]

其中：異常類可以聲明多個，用逗號分割。

區別二：throw要麼和try-catch-finally語句配套使用，要麼與throws配套使用。但throws可以單獨使用，然後再由處理異常的方法捕獲。

聯絡一：try .... catch 就是用catch 捕獲try 中的異常，並處理；catch是捕獲異常。也就是說某一個操作有可能會拋出什麼異常。throw
就是不處理異常，直接拋出異常

調用一個會throws exception的方法（在方法定義的時候可以用throws實現）時，需要把這個方法放在try裡，然後用catch破獲這個exception，做相應的處理。

throw new exception（）是拋出一個exception，由別的method來破獲它。

也就是說try....catch是為破獲別人的exception用的，而throw是自己拋出exception讓別人去破獲的。

public void input() throws Exception

{ }

public void outputException()

{

try {

input();

}

catch(Exception e)

{

System.out.println("Exception");

}

}

簡單的說，如果一個方法中用了throws，那麼這個方法會向上拋出一個異常，那麼在調用這個方法的時候必須把這個調用放在try...catch塊裡處理這個異常。

對於異常有兩種處理方法

1、要麼聲明異常，也就是在方法名後面加上throws exceptionname,..., 方法本身只是拋出異常，由函數調用者來捕獲異常。若產生異常，異常會沿著調用棧下移，一直找到與之匹配的處理方法，若到達調用棧底仍未找到，程式終止。

2、要麼捕獲異常。通過try catch方法，catch子句中放置處理異常的語句。

聯絡二：對於會覺得會有異常拋出的程式塊，用try{}包住，然後用catch來抓住這個異常，在catch中對異常做處理， 在try中如果有異常的話，程式會轉到catch而不會中斷，通常這兩個是配合使用的,如果你不想因為程式有錯，而拋出一大堆異常的話，你就把該程式try起來，try和catch只能擷取程式運行時引發的異常，而throw語句可以引發明確的異常，程式到了throw語句這後就立即停止，不會執行後面的程式,

大家也許在編程的過程中，會意識到這裡出錯，但不知道會拋出什麼異常，也是一件頭疼的事，現將這部分總結如下：

算術異常類：ArithmeticExecption
null 指標異常類：NullPointerException
類型強制轉換異常：ClassCastException
數組負下標異常：NegativeArrayException
數組下標越界異常：ArrayIndexOutOfBoundsException
違背安全原則異常：SecturityException
檔案已結束異常：EOFException
檔案未找到異常：FileNotFoundException
字串轉換為數字異常：NumberFormatException
操作資料庫異常：SQLException
輸入輸出異常：IOException
方法未找到異常：NoSuchMethodException

 

 

 

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. ?
?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塊。

class myException extends Exception{
? String msg;
? myException(int age){
? msg="age can not be positive!";
? }
? public String toString(){
? return msg;
? } ?
}

class Age{
? public void intage(int n) throws myException{//
? if(n<0||n>120){
? myException e=new myException(n);
? throw e; //是一個轉向語句，拋出對象執行個體，停止執行後面的代碼
? }
? if(n>=0){
? System.out.print("公道的年齡!");
? }
? }
? ?
public static void main(String args[]) {
? int a=-5;
? try { //try catch 必須有
? Age age = new Age();
? age.intage(a);//觸發異常
? System.out.print("拋出異常後的代碼") ;//這段代碼是不會被執行的，程式已經被轉向
? } catch (myException ex) {
? System.out.print(ex.toString());
? }
? finally{//無論拋不拋異常，無論catch語句的異常類型是否與所拋出的例外的類型一致，finally所指定的代碼都要被執行，它提供了同一的出口。
? System.out.print("進進finally！ ");
? }
? }
}

結果：年齡非法！ 進進finally！?

又如：
void fun()throws IOException,SQLException?
{?
...?
}?
這表示 fun方法可能會丟兩個異常出來，那麼在調用fun的時候就會做好預備，比如可以這樣?
try?
{?
fun();?
}catch(IOException e)?
{?
}catch(SQLException e)?
{?

}

?

?

區別一：

? throw 是語句拋出一個異常；throws 是方法拋出一個異常；

? throw文法：throw <異常對象>

? 在方法聲明中，添加throws子句表示該方法將拋出異常。

? throws文法：[<修飾符>]<傳回值類型><方法名>（[<參數列表>]）[throws<異常類>]

? 其中：異常類可以聲明多個，用逗號分割。

區別二：

? throws可以單獨使用，但throw不能；

區別三：

? throw要麼和try-catch-finally語句配套使用，要麼與throws配套使用。但throws可以單獨使 用，然後再由處理異常的方法捕捉。

?

throws E1,E2,E3 只是告訴程式這個方法可能會拋出這些個異常，方法的調用者可能要處理這些異常。而這些異常E1，E2，E3可能是該函數體產生的。

而throw是明確之處這個地方要拋出這個異常。

void doA() throws Exception1, Exception3 {
? try {
? ……
? } catch(Exception1 e) {
? throw e;
? } catch(Exception2 e) {
? System.out.println("出錯了");
? }
? if (a != b)
? throw new Exception3("自訂異常");
}

代碼塊……中可能產生異常Exception1、Exception2和Exception3。
假如產生Exception1異常，則捕捉了之後拋出由該方法的調用者往做處理；
假如產生Exception2異常，則該方法自己做了處理(列印出了說出錯了)，所以該方法就不會再向外拋出Exception2異常了，void doA() throws Exception1,,Excpetion3裡面的Exception2也就不用寫了；
而Exception3異常是該方法的某段邏輯出錯，程式員自己作了處理在該段邏輯錯誤的情況下拋出異常Exception3，則調用者也需要處理。

throw語句用在方法體內,表示拋出異常,由方法體內的語句處理?
throws語句用在方法聲明後面,表示再拋出異常,由調用這個方法的上一級方法中的語句來處理

throws主要是聲明這個方法會拋出這種類型的異常，使其他地方調用它時知道要捕捉這個異常。
throw是具體向外拋異常的動作，所以它是拋出一個異常執行個體。

throws說明你有哪個可能，傾向?
throw的話，那就是你把那個傾向變成真實的了
同時：
1）throws出現在方法函數頭；而throw出現在函數體；?
2）throws表示出現異常的一種可能性，並不一定會發生這些異常；throw則是拋出了異常，執行throw則一定拋出了某種異常；?
3）兩者都是消極處理異常的方式（這裡的消極並不是說這種方式不好），只是拋出或者可能拋出異常，但是不會由函數往處理異常，真正的處理異常由函數的上層調用處理。