歡迎光臨
每天分享高質量文章

Java中關於try、catch、finally中的細節分析

來自: God Is Coder
連結:http://www.cnblogs.com/aigongsi/archive/2012/04/19/2457735.html

本文講解的是關於Java中關於try、catch、finally中一些問題

下麵看一個例子(例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) {
           t = "catch";
           return t;
       } finally {
           t = "finally";
       }
   }

   public static void main(String[] args) {
       System.out.print(TryCatchFinally.test());
   }

}

 首先程式執行try陳述句塊,把變數t賦值為try,由於沒有發現異常,接下來執行finally陳述句塊,把變數t賦值為finally,然後return t,則t的值是finally,最後t的值就是finally,程式結果應該顯示finally,但是實際結果為try。為什麼會這樣,我們不妨先看看這段程式碼編譯出來的class對應的位元組碼,看虛擬機器內部是如何執行的。

我們用javap -verbose TryCatchFinally 來顯示標的檔案(.class檔案)位元組碼資訊

系統執行環境:mac os lion系統 64bit

jdk資訊:Java(TM) SE Runtime Environment (build 1.6.0_29-b11-402-11M3527) Java HotSpot(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    13   Class java/lang/Exception

    3     8    24   any
   13    19    24   any
 LineNumberTable:
  line 5: 0
  line 8: 3
  line 9: 6
  line 15: 8
  line 9: 11
  line 10: 13
  line 12: 14
  line 13: 17
  line 15: 19
  line 13: 22
  line 14: 24
  line 15: 25
  line 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 = 2
  frame_type = 255 /* full_frame */
    offset_delta = 13
    locals = [ 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 class TryCatchFinally {
2
3     @SuppressWarnings("finally")
4     public static final String test() {
5         String t = "";
6
7         try {
8             t = "try";
9             return t;
10         } catch (Exception e) {
11             // result = "catch";
12             t = "catch";
13             return t;
14         } finally {
15             t = "finally";
16             return t;
17         }
18     }
19
20     public static void main(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     9   Class java/lang/Exception

    3    16    16   any
 LineNumberTable:
  line 5: 0
  line 8: 3
  line 9: 6
  line 10: 9
  line 12: 10
  line 13: 13
  line 14: 16
  line 15: 17
  line 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 = 3
  frame_type = 255 /* full_frame */
    offset_delta = 9
    locals = [ 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 class TryCatchFinally {

   @SuppressWarnings("finally")
   public static final String test() {
       String t = "";
       try {
           t = "try";
           Integer.parseInt(null);
           return t;
       } catch (Exception e) {
           t = "catch";
           return t;
       } finally {
           t = "finally";
           // System.out.println(t);
           // return t;
       }
   }

   public static void main(String[] args) {
       System.out.print(TryCatchFinally.test());
   }

}

這裡面try陳述句裡面會丟擲 java.lang.NumberFormatException,所以程式會先執行catch陳述句中的邏輯,t賦值為catch,在執行return之前,會把傳回值儲存到一個臨時變數裡面t ‘,執行finally的邏輯,t賦值為finally,但是傳回值和t’,所以變數t的值和傳回值已經沒有關係了,傳回的是catch

例4:

public class TryCatchFinally {

   @SuppressWarnings("finally")
   public static final String test() {
       String t = "";
       try {
           t = "try";
           Integer.parseInt(null);
           return t;
       } catch (Exception e) {
           t = "catch";
           return t;
       } finally {
           t = "finally";
           return t;
       }
   }

   public static void main(String[] args) {
       System.out.print(TryCatchFinally.test());
   }

}

這個和例2有點類似,由於try陳述句裡面丟擲異常,程式轉入catch陳述句塊,catch陳述句在執行return陳述句之前執行finally,而finally陳述句有return,則直接執行finally的陳述句值,傳回finally

例5:

public class TryCatchFinally {

   @SuppressWarnings("finally")
   public static final String test() {
       String t = "";

       try {
           t = "try";
           Integer.parseInt(null);
           return t;
       } catch (Exception e) {
           t = "catch";
           Integer.parseInt(null);
           return t;
       } finally {
           t = "finally";
           //return t;
       }
   }

   public static void main(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 class TryCatchFinally {

   @SuppressWarnings("finally")
   public static final String test() {
       String t = "";

       try {
           t = "try";
           Integer.parseInt(null);
           return t;
       } catch (Exception e) {
           t = "catch";
           Integer.parseInt(null);
           return t;
       } finally {
           t = "finally";
           return t;
       }
   }

   public static void main(String[] args) {
       System.out.print(TryCatchFinally.test());
   }

}

這個例子和上面例子中唯一不同的是,這個例子裡面finally 陳述句裡面有return陳述句塊。try catch中執行的邏輯和上面例子一樣,當catch陳述句塊裡面丟擲異常之後,進入finally陳述句快,然後傳回t。則程式忽略catch陳述句塊裡面丟擲的異常資訊,直接傳回t對應的值 也就是finally。方法不會丟擲異常

例子7:

public class TryCatchFinally {

   @SuppressWarnings("finally")
   public static final String test() {
       String t = "";

       try {
           t = "try";
           Integer.parseInt(null);
           return t;
       } catch (NullPointerException e) {
           t = "catch";
           return t;
       } finally {
           t = "finally";
       }
   }

   public static void main(String[] args) {
       System.out.print(TryCatchFinally.test());
   }

}

這個例子裡面catch陳述句裡面catch的是NPE異常,而不是java.lang.NumberFormatException異常,所以不會進入catch陳述句塊,直接進入finally陳述句塊,finally對s賦值之後,由try陳述句丟擲java.lang.NumberFormatException異常。

例子8

public class TryCatchFinally {

   @SuppressWarnings("finally")
   public static final String test() {
       String t = "";

       try {
           t = "try";
           Integer.parseInt(null);
           return t;
       } catch (NullPointerException e) {
           t = "catch";
           return t;
       } finally {
           t = "finally";
           return t;
       }
   }

   public static void main(String[] args) {
       System.out.print(TryCatchFinally.test());
   }

}

和上面的例子中try catch的邏輯相同,try陳述句執行完成執行finally陳述句,finally賦值s 並且傳回s ,最後程式結果傳回finally

例子9:

public class TryCatchFinally {

   @SuppressWarnings("finally")
   public static final String test() {
       String t = "";

       try {
           t = "try";return t;
       } catch (Exception e) {
           t = "catch";
           return t;
       } finally {
           t = "finally";
           String.valueOf(null);
           return t;
       }
   }

   public static void main(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塊中的異常


●本文編號624,以後想閱讀這篇文章直接輸入624即可

●輸入m獲取文章目錄

推薦↓↓↓

 

演演算法與資料結構

更多推薦18個技術類微信公眾號

涵蓋:程式人生、演演算法與資料結構、駭客技術與網路安全、大資料技術、前端開發、Java、Python、Web開發、安卓開發、iOS開發、C/C++、.NET、Linux、資料庫、運維等。

贊(0)

分享創造快樂