throw和throws的區別以及try,catch,finally在有return的狀況下執行的順序

一，拋出異常有三種形式，一是throw,一個throws，還有一種系統自動拋異常。下面它們之間的異同。

（1）、系統自動拋異常

1.當程序語句出現一些邏輯錯誤、主義錯誤或類型轉換錯誤時，系統會自動拋出異常：

public static void main(String[] args) { 
    int a = 5, b =0; 
    System.out.println(5/b); 
    //function(); 
}

系統會自動拋出ArithmeticException異常。

2.

public static void main(String[] args) { 
    String s = "abc"; 
    System.out.println(Double.parseDouble(s)); 
    //function(); 
}

系統會自動拋出NumberFormatException異常。

（2）、throw

throw是語句拋出一個異常，通常是在代碼塊的內部，當程序出現某種邏輯錯誤時由程序員主動拋出某種特定類型的異常

public static void main(String[] args) { 
    String s = "abc"; 
    if(s.equals("abc")) { 
      throw new NumberFormatException(); 
    } else { 
      System.out.println(s); 
    } 
    //function(); 
}

運行時，系統會拋出異常：

Exception in thread "main" java.lang.NumberFormatException

（3）、throws

throws是方法可能拋出異常的聲明。(用在聲明方法時，表示該方法可能要拋出異常)

public void function() throws Exception{......}

當某個方法可能會拋出某種異常時用於throws 聲明可能拋出的異常，而後交給上層調用它的方法程序處理

public class testThrows {
 
    public static void function() throws NumberFormatException {
        String s = "abc";
        System.out.println(Double.parseDouble(s));
    }
 
    public static void main(String[] args) {
        try {
            function();
        } catch (NumberFormatException e) {
            System.err.println("非數據類型不能強制類型轉換。");
            //e.printStackTrace(); 
        }
    }
}

運行結果：

非數據類型不能強制類型轉換。

（4）、throw與throws的比較
    throws出如今方法函數頭；而throw出如今函數體。
    throws表示出現異常的一種可能性，並不必定會發生這些異常；throw則是拋出了異常，執行throw則必定拋出了某種異常對象。
    二者都是消極處理異常的方式（這裏的消極並非說這種方式很差），只是拋出或者可能拋出異常，可是不會由函數去處理異常，真正的處理異常由函數的上層調用處理。

（5）、編程習慣 

    在寫程序時，對可能會出現異常的部分一般要用try{...}catch{...}去捕捉它並對它進行處理；
    用try{...}catch{...}捕捉了異常以後必定要對在catch{...}中對其進行處理，那怕是最簡單的一句輸出語句，或棧輸入e.printStackTrace();
    若是是捕捉IO輸入輸出流中的異常，必定要在try{...}catch{...}後加finally{...}把輸入輸出流關閉；
    若是在函數體內用throw拋出了某種異常，最好要在函數名中加throws拋異常聲明，而後交給調用它的上層函數進行處理。

二，try,catch,finally在有return的狀況下執行的順序

結論：

一、無論有木有出現異常，finally塊中代碼都會執行；

二、當try和catch中有return時，finally仍然會執行；

三、finally是在return後面的表達式運算後執行的（此時並無返回運算後的值，而是先把要返回的值保存起來，管finally中的代碼怎麼樣，返回的值都不會改變，任然是以前保存的值），因此函數返回值是在finally執行前肯定的；

四、finally中最好不要包含return，不然程序會提早退出，返回值不是try或catch中保存的返回值。

舉例：

狀況1：

try{} catch(){}finally{} return;

顯然程序按順序執行。

狀況2:

try{ return; }catch(){} finally{} return;

程序執行try塊中return以前（包括return語句中的表達式運算）代碼；再執行finally塊，最後執行try中return;finally塊以後的語句return，由於程序在try中已經return因此再也不執行。
狀況3:

try{ } catch(){return;} finally{} return;

程序先執行try，若是遇到異常執行catch塊，
 有異常：則執行catch中return以前（包括return語句中的表達式運算）代碼，再執行finally語句中所有代碼，最後執行catch塊中return. finally以後也　　　　　就是4處的代碼再也不執行。
 無異常：執行完try再finally再return.
狀況4:

try{ return; }catch(){} finally{return;}

 程序執行try塊中return以前（包括return語句中的表達式運算）代碼；再執行finally塊，由於finally塊中有return因此提早退出。
狀況5:

try{} catch(){return;}finally{return;}

程序執行catch塊中return以前（包括return語句中的表達式運算）代碼；再執行finally塊，由於finally塊中有return因此提早退出。
狀況6:

try{ return;}catch(){return;} finally{return;}

程序執行try塊中return以前（包括return語句中的表達式運算）代碼；
  有異常：執行catch塊中return以前（包括return語句中的表達式運算）代碼；則再執行finally塊，由於finally塊中有return因此提早退出。
  無異常：則再執行finally塊，由於finally塊中有return因此提早退出。
最終結論：

任何執行try 或者catch中的return語句以前，都會先執行finally語句，若是finally存在的話，若是finally中有return語句，那麼程序就return了，因此finally中的return是必定會被return的，編譯器把finally中的return實現爲一個warning。

下面是個測試程序

public class FinallyTest  
{
    public static void main(String[] args) {
         
        System.out.println(new FinallyTest().test());;
    }

    static int test()
    {
        int x = 1;
        try
        {
            x++;
            return x;
        }
        finally
        {
            ++x;
        }
    }
}

結果是2。

分析：

在try語句中，在執行return語句時，要返回的結果已經準備好了，就在此時，程序轉到finally執行了。 在轉去以前，try中先把要返回的結果存放到不一樣於x的局部變量中去，執行完finally以後，在從中取出返回結果， 所以，即便finally中對變量x進行了改變，可是不會影響返回結果。 它應該使用棧保存返回值。

參考博客：

https://blog.csdn.net/hjfcgt123/article/details/53349275

https://blog.csdn.net/kavensu/article/details/8067850