java try 返回值_JAVA的try... catch finally的return返回值问题
下面看一個例子(例1)，來講解Java里面中try、catch、finally的處理流程
public class TryCatchFinally {
@SuppressWarnings("finally")
public static final String test() {
String t = "";
try {
t = "try";
return t;
} catch (Exception e) {
// result = "catch";
t = "catch";
return t;
} finally {
t = "finally";
}
}
public static void main(String[] args) {
System.out.print(TryCatchFinally.test());
}
}
我們用javap -verbose TryCatchFinally 來顯示目標文件(.class文件)字節碼信息
系統運行環境：mac os lion系統 64bit
jdk信息：Java(TM) SE Runtime Environment (build 1.6.0_29-b11-402-11M3527)?JavaHotSpot(TM) 64-Bit Server VM (build 20.4-b02-402, mixed mode)
編譯出來的字節碼部分信息，我們只看test方法，其他的先忽略掉
public static final java.lang.String test();
Code:Stack=1, Locals=4, Args_size=0
0: ldc #16;//String
2: astore_0
3: ldc #18;//String try
5: astore_0
6: aload_0
7: astore_3
8: ldc #20;//String finally
10: astore_0
11: aload_3
12: areturn
13: astore_1
14: ldc #22;//String catch
16: astore_0
17: aload_0
18: astore_3
19: ldc #20;//String finally
21: astore_0
22: aload_3
23: areturn
24: astore_2
25: ldc #20;//String finally
27: astore_0
28: aload_2
29: athrow
Exception table:from to target type
3 8 13Class java/lang/Exception
3 8 24any
13 19 24any
LineNumberTable:line 5: 0line 8: 3line 9: 6line 15: 8line 9: 11line 10: 13line 12: 14line 13: 17line 15: 19line 13: 22line 14: 24line 15: 25line 16: 28
LocalVariableTable:Start Length Slot Name Signature
3 27 0 t Ljava/lang/String;
14 10 1 e Ljava/lang/Exception;
StackMapTable: number_of_entries = 2frame_type = 255/* full_frame */
offset_delta = 13locals = [ class java/lang/String ]
stack = [ class java/lang/Exception ]
frame_type = 74/* same_locals_1_stack_item */
stack = [ class java/lang/Throwable ]
首先看LocalVariableTable信息，這里面定義了兩個變量 一個是t String類型,一個是e Exception 類型
接下來看Code部分
第[0-2]行，給第0個變量賦值“”，也就是String t=""；
第[3-6]行，也就是執行try語句塊 賦值語句 ，也就是 t = "try";
第7行，重點是第7行，把第s對應的值"try"付給第三個變量，但是這里面第三個變量并沒有定義,這個比較奇怪
第[8-10] 行，對第0個變量進行賦值操作，也就是t="finally"
第[11-12]行，把第三個變量對應的值返回
通過字節碼，我們發現，在try語句的return塊中，return 返回的引用變量(t 是引用類型)并不是try語句外定義的引用變量t，而是系統重新定義了一個局部引用t’，這個引用指向了引用t對應的值，也就是try ，即使在finally語句中把引用t指向了值finally，因為return的返回引用已經不是t ，所以引用t的對應的值和try語句中的返回值無關了。
下面在看一個例子：(例2)
1 public classTryCatchFinally {
2
3 @SuppressWarnings("finally")
4 public static finalString test() {
5 String t = "";
6
7 try{
8 t = "try";
9 returnt;
10 } catch(Exception e) {
11 //result = "catch";
12 t = "catch";
13 returnt;
14 } finally{
15 t = "finally";
16 returnt;
17 }
18 }
19
20 public static voidmain(String[] args) {
21 System.out.print(TryCatchFinally.test());
22 }
23
24 }
這里稍微修改了 第一段代碼，只是在finally語句塊里面加入了 一個 return t 的表達式。
按照第一段代碼的解釋，先進行try{}語句，然后在return之前把當前的t的值try保存到一個變量t'，然后執行finally語句塊，修改了變量t的值，在返回變量t。
這里面有兩個return語句，但是程序到底返回的是try 還是 finally。接下來我們還是看字節碼信息
public static final java.lang.String test();
Code:Stack=1, Locals=2, Args_size=0
0: ldc #16;//String
2: astore_0
3: ldc #18;//String try
5: astore_0
6: goto 17
9: astore_1
10: ldc #20;//String catch
12: astore_0
13: goto 17
16: pop
17: ldc #22;//String finally
19: astore_0
20: aload_0
21: areturn
Exception table:from to target type
3 9 9Class java/lang/Exception
3 16 16any
LineNumberTable:line 5: 0line 8: 3line 9: 6line 10: 9line 12: 10line 13: 13line 14: 16line 15: 17line 16: 20
LocalVariableTable:Start Length Slot Name Signature
3 19 0 t Ljava/lang/String;
10 6 1 e Ljava/lang/Exception;
StackMapTable: number_of_entries = 3frame_type = 255/* full_frame */
offset_delta = 9locals = [ class java/lang/String ]
stack = [ class java/lang/Exception ]
frame_type = 70/* same_locals_1_stack_item */
stack = [ class java/lang/Throwable ]
frame_type = 0 /* same */
這段代碼翻譯出來的字節碼和第一段代碼完全不同，還是繼續看code屬性
第[0-2]行、[3-5]行第一段代碼邏輯類似，就是初始化t，把try中的t進行賦值try
第6行，這里面跳轉到第17行，[17-19]就是執行finally里面的賦值語句，把變量t賦值為finally，然后返回t對應的值
我們發現try語句中的return語句給忽略。可能jvm認為一個方法里面有兩個return語句并沒有太大的意義，所以try中的return語句給忽略了，直接起作用的是finally中的return語句，所以這次返回的是finally。
接下來在看看復雜一點的例子：(例3)
public classTryCatchFinally {
@SuppressWarnings("finally")
public static finalString test() {
String t = "";
try{
t = "try";
Integer.parseInt(null);
returnt;
} catch(Exception e) {
t = "catch";
returnt;
} finally{
t = "finally";
//System.out.println(t);
//return t;
}
}
public static voidmain(String[] args) {
System.out.print(TryCatchFinally.test());
}
}
這里面try語句里面會拋出?java.lang.NumberFormatException，所以程序會先執行catch語句中的邏輯，t賦值為catch，在執行return之前，會把返回值保存到一個臨時變量里面t '，執行finally的邏輯，t賦值為finally，但是返回值和t'，所以變量t的值和返回值已經沒有關系了，返回的是catch
例4：
public classTryCatchFinally {
@SuppressWarnings("finally")
public static finalString test() {
String t = "";
try{
t = "try";
Integer.parseInt(null);
returnt;
} catch(Exception e) {
t = "catch";
returnt;
} finally{
t = "finally";
returnt;
}
}
public static voidmain(String[] args) {
System.out.print(TryCatchFinally.test());
}
}
這個和例2有點類似，由于try語句里面拋出異常，程序轉入catch語句塊，catch語句在執行return語句之前執行finally，而finally語句有return,則直接執行finally的語句值，返回finally
例5：
public classTryCatchFinally {
@SuppressWarnings("finally")
public static finalString test() {
String t = "";
try{
t = "try";
Integer.parseInt(null);
returnt;
} catch(Exception e) {
t = "catch";
Integer.parseInt(null);
returnt;
} finally{
t = "finally";
//return t;
}
}
public static voidmain(String[] args) {
System.out.print(TryCatchFinally.test());
}
}
這個例子在catch語句塊添加了Integer.parser(null)語句，強制拋出了一個異常。然后finally語句塊里面沒有return語句。繼續分析一下，由于try語句拋出異常，程序進入catch語句塊，catch語句塊又拋出一個異常，說明catch語句要退出，則執行finally語句塊，對t進行賦值。然后catch語句塊里面拋出異常。結果是拋出java.lang.NumberFormatException異常
例子6：
public classTryCatchFinally {
@SuppressWarnings("finally")
public static finalString test() {
String t = "";
try{
t = "try";
Integer.parseInt(null);
returnt;
} catch(Exception e) {
t = "catch";
Integer.parseInt(null);
returnt;
} finally{
t = "finally";
returnt;
}
}
public static voidmain(String[] args) {
System.out.print(TryCatchFinally.test());
}
}
這個例子和上面例子中唯一不同的是，這個例子里面finally 語句里面有return語句塊。try catch中運行的邏輯和上面例子一樣，當catch語句塊里面拋出異常之后，進入finally語句快，然后返回t。則程序忽略catch語句塊里面拋出的異常信息，直接返回t對應的值 也就是finally。方法不會拋出異常
例子7：
public classTryCatchFinally {
@SuppressWarnings("finally")
public static finalString test() {
String t = "";
try{
t = "try";
Integer.parseInt(null);
returnt;
} catch(NullPointerException e) {
t = "catch";
returnt;
} finally{
t = "finally";
}
}
public static voidmain(String[] args) {
System.out.print(TryCatchFinally.test());
}
}
這個例子里面catch語句里面catch的是NPE異常，而不是java.lang.NumberFormatException異常，所以不會進入catch語句塊，直接進入finally語句塊，finally對s賦值之后，由try語句拋出java.lang.NumberFormatException異常。
例子8
public classTryCatchFinally {
@SuppressWarnings("finally")
public static finalString test() {
String t = "";
try{
t = "try";
Integer.parseInt(null);
returnt;
} catch(NullPointerException e) {
t = "catch";
returnt;
} finally{
t = "finally";
returnt;
}
}
public static voidmain(String[] args) {
System.out.print(TryCatchFinally.test());
}
}
和上面的例子中try catch的邏輯相同，try語句執行完成執行finally語句，finally賦值s 并且返回s ，最后程序結果返回finally
例子9：
public classTryCatchFinally {
@SuppressWarnings("finally")
public static finalString test() {
String t = "";
try{
t = "try";returnt;
} catch(Exception e) {
t = "catch";
returnt;
} finally{
t = "finally";
String.valueOf(null);
returnt;
}
}
public static voidmain(String[] args) {
System.out.print(TryCatchFinally.test());
}
}
這個例子中，對finally語句中添加了String.valueOf(null), 強制拋出NPE異常。首先程序執行try語句，在返回執行，執行finally語句塊，finally語句拋出NPE異常，整個結果返回NPE異常。
對以上所有的例子進行總結
1 try、catch、finally語句中，在如果try語句有return語句，則返回的之后當前try中變量此時對應的值，此后對變量做任何的修改，都不影響try中return的返回值
2 如果finally塊中有return 語句，則返回try或catch中的返回語句忽略。
3 如果finally塊中拋出異常，則整個try、catch、finally塊中拋出異常
所以使用try、catch、finally語句塊中需要注意的是
1 盡量在try或者catch中使用return語句。通過finally塊中達到對try或者catch返回值修改是不可行的。
2 finally塊中避免使用return語句，因為finally塊中如果使用return語句，會顯示的消化掉try、catch塊中的異常信息，屏蔽了錯誤的發生
3 finally塊中避免再次拋出異常，否則整個包含try語句塊的方法回拋出異常，并且會消化掉try、catch塊中的異常
結論：
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進行了改變，但是不會影響返回結果。
它應該使用棧保存返回值。
與50位技術專家面對面20年技術見證，附贈技術全景圖總結
以上是生活随笔為你收集整理的java try 返回值_JAVA的try... catch finally的return返回值问题的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 14858×1000等于多少乘1000不
- 下一篇： java对象的访问定位_JVM创建对象及