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的情況下執行的順序

結論：

1、不管有木有出現異常，finally塊中代碼都會執行；

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

3、finally是在return后面的表達式運算后執行的（此時並沒有返回運算后的值，而是先把要返回的值保存起來，管finally中的代碼怎么樣，返回的值都不會改變，任然是之前保存的值），所以函數返回值是在finally執行前確定的；

4、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