throw跟throws關鍵字

throws關鍵字

定義一個方法的時候可以使用throws關鍵字聲明。使用throws關鍵字聲明的方法表示此方法不處理異常，而交給方法調用處進行處理。

throws關鍵字格式：

public 返回值類型 方法名稱（參數列表，，，）throws 異常類{}；

 假設定義一個除法，對於除法操作可能出現異常，可能不會。所以對於這種方法最好將它使用throws關鍵字聲明，一旦出現異常，

則應該交給調用處處理。

class Math{
    public int div(int i,int j) throws Exception{    // 定義除法操作，如果有異常，則交給被調用處處理
        int temp = i / j ;    // 計算，但是此處有可能出現異常
        return temp ;
    }
};
public class ThrowsDemo01{
    public static void main(String args[]){
        Math m = new Math() ;        // 實例化Math類對象
        try{
            System.out.println("除法操作：" + m.div(10,2)) ;
        }catch(Exception e){  e.printStackTrace() ; // 打印異常
        }
    }
};

因為div使用了throws關鍵字聲明，所以調用此方法的時候，方法必須進行異常處理。通過try...catch；

 

如果在主方法的聲明也使用了throws關鍵字呢，那么是不是意味着主方法也可以不處理異常。

class Math{
    public int div(int i,int j) throws Exception{    // 定義除法操作，如果有異常，則交給被調用處處理
        int temp = i / j ;    // 計算，但是此處有可能出現異常
        return temp ;
    }
};
public class ThrowsDemo02{
    // 在主方法中的所有異常都可以不使用try...catch進行處理
    public static void main(String args[]) throws Exception{
        Math m = new Math() ;        // 實例化Math類對象
        System.out.println("除法操作：" + m.div(10,0)) ;
    }
};
運行結果：

Exception in thread "main" java.lang.ArithmeticException: / by zero
at methoud.Math.div(ThisDemo06.java:4)
at methoud.ThisDemo06.main(ThisDemo06.java:12)

在本程序中，主方法不處理任何異常，而交給JAVA中最大頭JVM，所以如果在主方法使用了throws關鍵字，則表示一切異常

交給JVM進行處理。默認處理方式也是JVM完成。

throw關鍵字

throw關機字作用是拋出一個異常，拋出的時候是拋出的是一個異常類的實例化對象，

在異常處理中，try語句要捕獲的是一個異常對象，那么此異常對象也可以自己拋出。

package methoud;
public class ThisDemo06{
    public static void main(String args[]){
        try{
            throw new Exception("自己拋着玩的。") ;    // 拋出異常的實例化對象
        }catch(Exception e){
            System.out.println(e) ;
        }
    }
};

范例，throw與throws的應用

在一般開發中，try，，catch，，finally，throw，throws聯合使用的情況是最多的。

例如，現在要使用一個相除的方法，但是在操作之前必須打印“運算開始”的信息，結束之后必須打印“異常結束”。

如果有異常，需要把異常交給異常調用處處理。面對這樣要求，必須全部使用以上關鍵字。

class Math{
    public int div(int i,int j) throws Exception{    // 定義除法操作，如果有異常，則交給被調用處處理
        System.out.println("***** 計算開始 *****") ;
        int temp = i / j ;    // 計算，但是此處有可能出現異常
        System.out.println("***** 計算結束 *****") ;
        return temp ;
    }
};
public class ThrowDemo02{
    public static void main(String args[]){
        Math m = new Math() ;
        try{
            System.out.println("除法操作：" + m.div(10,0)) ;
        }catch(Exception e){
            System.out.println("異常產生：" + e) ;
        }
    }
};
運行結果：

***** 計算開始 *****
異常產生：java.lang.ArithmeticException: / by zero

以上沒有計算結束，因為沒有異常發生了，直接中斷程序操作。所以做以下操作。

package methoud;
class Math{
    public int div(int i,int j) throws Exception{    // 定義除法操作，如果有異常，則交給被調用處處理
        System.out.println("***** 計算開始 *****") ;
        int temp = 0 ;    // 定義局部變量
        try{
            temp = i / j ;    // 計算，但是此處有可能出現異常
        }catch(Exception e){
        }
         System.out.println("***** 計算結束 *****") ;
        return temp ;
    }
};
public class ThisDemo06{
    public static void main(String args[]){
        Math m = new Math() ;
        try{
            System.out.println("除法操作：" + m.div(10,0)) ;
        }catch(Exception e){
            System.out.println("異常產生：" + e) ;
        }
    }
};
運行結果：

***** 計算開始 *****
***** 計算結束 *****
異常產生：java.lang.ArithmeticException: / by zero

這里雖然貌似成功了，但是，這里的異常並沒有拋出去，因為在方法中已經被自動處理了，沒有拋出去。

所以要拋出異常對象，給方法調用處處理，使用throw關鍵字。

package methoud;
class Math{
    public int div(int i,int j) throws Exception{    // 定義除法操作，如果有異常，則交給被調用處處理
        System.out.println("***** 計算開始 *****") ;
        int temp = 0 ;    // 定義局部變量
        try{
            temp = i / j ;    // 計算，但是此處有可能出現異常
        }catch(Exception e){
            throw e ;　　　　//拋出異常。
        }finally{    // 不管是否有異常，都要執行統一出口
            System.out.println("***** 計算結束 *****") ;
        }
        return temp ;
    }
};
public class ThisDemo06{
    public static void main(String args[]){
        Math m = new Math() ;
        try{
            System.out.println("除法操作：" + m.div(10,0)) ;
        }catch(Exception e){
            System.out.println("異常產生：" + e) ;
        }
    }
};

Exception與runtimeException區別

是面試中經常出現的問題。

觀察以下代碼：

package methoud;
public class ThisDemo06{
    public static void main(String args[]){
        String str = "123" ;    // 定義字符串，全部由數字組成
        int temp = Integer.parseInt(str) ; // 將字符串變為int類型
        System.out.println(temp * temp) ;    // 計算乘方
    }
};

parseInt（）的定義格式：

public static int parseInt(String s) throws NumberFormatException

此方法明明使用了throws關鍵字拋出異常，為什么不用處理，也可以編譯通過？

 

在JAVA異常處理機制中，

1）如果拋出的是EXception的類型，則必須進行try ..catch進行處理。

2）如果拋出的是RuntimeException的類型，則可以不使用try。。catch處理，一旦發生異常之后，將由JVM處理。

為了保證程序的健康性，在有可能出現異常的時候還是老實使用try  ..catch處理。

自定義異常類。

只需要繼承Exception類就可以自定義異常類。因為JAVA中提供的都是標准異常類（包括一些異常信息），如果需要自己想要

的異常信息就可以自定義異常類。

class MyException extends Exception{    // 自定義異常類，繼承Exception類
    public MyException(String msg){
        super(msg) ;    // 調用Exception類中有一個參數的構造方法，傳遞錯誤信息
    }
};
public class DefaultException{    
    public static void main(String args[]){
        try{
            throw new MyException("自定義異常。") ;     // 拋出異常
        }catch(Exception e){
            System.out.println(e) ;　　　　　　//打印錯誤信息
        }
    }
}
運行結果：

methoud.MyException: 自定義異常。

總結

throw與throws關鍵字聯合使用問題。

1）throw：拋出異常。

2）throws：在方法聲明處使用，表示此方法不處理異常，而在調用此方法處處理異常。

Exception是必須處理的，而RuntimeException異常是可以不處理的。但是為了保證程序正常運行，最好處理。

如果自定義異常，直接繼承異常即可。