前言

之前在刷筆試題和面試的時候經常會遇到或者被問到 try-catch-finally 語法塊的執行順序等問題，今天就抽空整理了一下這個知識點，然后記錄下來。

[[331347]]

正文

本篇文章主要是通過舉例的方式來闡述各種情況，我這里根據 try-catch-finally 語法塊分為兩種大情況討論：try-catch 語法塊和 try-catch-finally 語句塊，然后再在每種情況里再去具體討論。

一、try-catch 語句塊

我們可以看看下面程序：

public static void main(String[] args) { 
 
    System.out.println(handleException0()); 
  } 
 
  /** 
   * try,catch都有return 
   * @return 
   */ 
  private static String handleException0() { 
    try{ 
      System.out.println("try開始"); 
      String s = null; 
      int length = s.charAt(0); 
      System.out.println("try結束"); 
      return "try塊的返回值"; 
    }catch (Exception e){ 
      System.out.println("捕獲到了異常"); 
      return "catch的返回值"; 
    } 
  } 

執行結果：

try開始 捕獲到了異常 catch的返回值

分析：程序首先執行 try 塊里面的代碼，try 塊里面發現有異常，try 塊后面的代碼不會執行(自然也不會return)，然后進入匹配異常的那個 catch 塊，然后進入 catch 塊里面將代碼執行完畢，當執行到 catch 里面的return 語句的時候，程序中止，然后將此 return 的最終結果返回回去。

二、try-catch-finally 語句塊

這種語法塊我分為了 4 種情況討論，下面進行一一列舉。

第一種情況，try 塊里面有 return 的情況，并且捕獲到異常

例1：

public static void main(String[] args) { 
  String result = handleException1(); 
  System.out.println(result); 
} 
private static String handleException1() { 
  try{ 
    System.out.println("try開始"); 
    String str = null; 
    int length = str.length(); 
    System.out.println("try結束"); 
  }catch (Exception e){ 
    System.out.println("捕獲到了異常"); 
  }finally { 
    System.out.println("finally塊執行完畢了"); 
  } 
  return "最終的結果"; 
} 

例1執行的結果如下：

try開始 捕獲到了異常 finally塊執行完畢了 最終的結果

例2:

public static void main(String[] args) { 
  String result = handleException2(); 
  System.out.println(result); 
} 
private static String handleException2() { 
  try{ 
    System.out.println("try開始"); 
    String str = null; 
    int length = str.length(); 
    System.out.println("try結束"); 
    return "try塊的返回值"; 
  }catch (Exception e){ 
    System.out.println("捕獲到了異常"); 
  }finally { 
    System.out.println("finally塊執行完畢了"); 
  } 
  return "最終的結果"; 
} 

例2的執行結果如下：

try開始 捕獲到了異常 finally塊執行完畢了 最終的結果

分析：首先 例1 和 例2 的結果是很顯然的，當遇到異常的時候，直接進入匹配到相對應的 catch 塊，然后繼續執行 finallly 語句塊，最后將 return 結果返回回去。

第二種情況：try塊里面有return的情況，但是不會捕獲到異常

例3：

思考：下面代碼try語句塊中有return語句，那么是否執行完try語句塊就直接return退出方法了呢?

public static void main(String[] args) { 
  String result = handleException3(); 
  System.out.println(result); 
} 
private static String handleException3() { 
  try{ 
      System.out.println(""); 
    return "try塊的返回值"; 
  }catch (Exception e){ 
    System.out.println("捕獲到了異常"); 
  }finally { 
    System.out.println("finally塊執行完畢了"); 
  } 
  return "最終的結果"; 
} 

例3的執行結果如下：

finally塊執行完畢了 try塊的返回值

分析：例3的結果其實我們可以通過打斷點的方式去看看程序的具體執行流程，通過打斷點我們可以發現，代碼先執行 try塊 里的代碼，當執行到 return 語句的時候，handleException3方法并沒有立刻結束，而是繼續執行finally塊里的代碼，finally塊里的代碼執行完后，緊接著回到 try 塊的 return 語句，再把最終結果返回回去， handleException 方法執行完畢。

第三種情況：try塊和finally里面都有return的情況

例4：

public static void main(String[] args) { 
    System.out.println(handleException4()); 
  } 
 
  /** 
   * 情況3：try和finally中均有return 
   * @return 
   */ 
  private static String handleException4() { 
    try{ 
      System.out.println(""); 
      return "try塊的返回值"; 
    }catch (Exception e){ 
      System.out.println("捕獲到了異常"); 
    }finally { 
      System.out.println("finally塊執行完畢了"); 
      return "finally的返回值"; 
    } 
  //  return "最終的結果";//不能再有返回值 
  } 

例4的執行結果：

finally塊執行完畢了 finally的返回值

分析：需要注意的是，當 try 塊和 finally 里面都有 return 的時候，在 try/catch/finally 語法塊之外不允許再有return 關鍵字。我們還是通過在程序中打斷點的方式來看看代碼的具體執行流程。代碼首先執行 try 塊 里的代碼，當執行到 return 語句的時候，handleException4 方法并沒有立刻結束，而是繼續執行 finally 塊里的代碼，當發現 finally 塊里有 return 的時候，直接將 finally 里的返回值(也就是最終結果)返回回去， handleException4 方法執行完畢。

第四種情況：try塊,catch塊,finally塊都有return

例5：

public static void main(String[] args) { 
    System.out.println(handleException5()); 
  } 
 
  /** 
   * 情況4：try,catch,finally都有return 
   * @return 
   */ 
  private static String handleException5() { 
    try{ 
      System.out.println("try開始"); 
      int[] array = {1, 2, 3}; 
      int i = array[10]; 
      System.out.println("try結束"); 
      return "try塊的返回值"; 
    }catch (Exception e){ 
      e.printStackTrace();//這行代碼其實就是打印輸出異常的具體信息 
      System.out.println("捕獲到了異常"); 
      return "catch的返回值"; 
    }finally { 
      System.out.println("finally塊執行完畢了"); 
      return "finally的返回值"; 
    } 
//    return "最終的結果"; 
  } 

例5的執行結果：

try開始 捕獲到了異常 finally塊執行完畢了 finally的返回值  
java.lang.ArrayIndexOutOfBoundsException: 10 at  
com.example.javabasic.javabasic.ExceptionAndError.TryCatchFinally.handleException5(TryCatchFinally.java:25) at  
com.example.javabasic.javabasic.ExceptionAndError.TryCatchFinally.main(TryCatchFinally.java:14) 

分析：程序首先執行try塊里面的代碼，try塊里面發現有異常，try塊后面的代碼不會執行(自然也不會return)，然后進入匹配異常的那個catch塊，然后進入catch塊里面將代碼執行完畢，當執行到catch里面的return語句的時候，程序不會馬上終止，而是繼續執行finally塊的代碼，最后執行finally里面的return，然后將此return的最終結果返回回去。

總結

其實，我們通過以上例子我們可以發現，不管return關鍵字在哪，finally一定會執行完畢。理論上來說try、catch、finally塊中都允許書寫return關鍵字，但是執行優先級較低的塊中的return關鍵字定義的返回值將覆蓋執行優先級較高的塊中return關鍵字定義的返回值。也就是說finally塊中定義的返回值將會覆蓋catch塊、try塊中定義的返回值;catch塊中定義的返回值將會覆蓋try塊中定義的返回值。 再換句話說如果在finally塊中通過return關鍵字定義了返回值，那么之前所有通過return關鍵字定義的返回值都將失效——因為finally塊中的代碼一定是會執行的。

本文授權轉載自公眾號「良許Linux」。良許，世界500強外企Linux開發工程師，公眾號里分享大量Linux干貨，歡迎關注!