有return的情况下try catch finally的执行顺序

一、举例说明情况：

例1、try{} --> catch(){} --> finally{} --> return;

显然程序按顺序执行。

 1 /**
 2      * 例1、try{} -->   catch(){} --> finally{} -->  return;
 3      */
 4     static Integer f1(){
 5         try {
 6             System.out.println("情况1try");
 7         }catch (Exception e){
 8             System.out.println("情况1catch");
 9         }finally {
10             System.out.println("情况1finally");
11         }
12         return 0;
13     }

例2、try{ return; } --> catch(){} --> finally{} --> return;

程序执行try块中return之前（包括return语句中的表达式运算）代码；

再执行finally块，最后执行try中return;

finally块之后的语句return，因为程序在try中已经return所以不再执行。

 1 /**
 2      * try{ return; } --> catch(){}  --> finally{}  --> return;
 3      * @return
 4      */
 5     static Integer f2(){
 6         try {
 7             System.out.println("情况2try");
 8             return 1;
 9         }catch (Exception e){
10             System.out.println("情况2catch");
11         }finally {
12             System.out.println("情况2finally");
13         }
14         return 0;
15     }

例3、try{ } --> catch(){return;} --> finally{} --> return;

程序先执行try，如果遇到异常执行catch块，

有异常：则执行catch中return之前（包括return语句中的表达式运算）代码，再执行finally语句中全部代码，

最后执行catch块中return. finally之后也就是4处的代码不再执行。

无异常：执行完try再finally再return.

 1 /**
 2      * try{ } --> catch(){return;}  --> finally{} --> return;
 3      * @return
 4      */
 5     static Integer f3(){
 6         try {
 7             System.out.println("情况3try");
 8             //int a = 1/0;
 9         }catch (Exception e){
10             System.out.println("情况3catch");
11             return 1;
12         }finally {
13             System.out.println("情况3finally");
14         }
15         return 0;
16     }

无异常：

有异常：

例4、try{ return; } --> catch(){} --> finally{return;}

程序执行try块中return之前（包括return语句中的表达式运算）代码；

再执行finally块，因为finally块中有return所以提前退出。

 1 /**
 2      * try{ return; } --> catch(){} --> finally{return;}
 3      * @return
 4      */
 5     static Integer f4(){
 6         try {
 7             System.out.println("情况4try");
 8             return 1;
 9         }catch (Exception e){
10             System.out.println("情况4catch");
11         }finally {
12             System.out.println("情况4finally");
13             return 2;
14         }
15     }

例5、try{} --> catch(){return;} --> finally{return;}

有异常：程序执行catch块中return之前（包括return语句中的表达式运算）代码；

再执行finally块，因为finally块中有return所以提前退出。

无异常：顺序执行

 1 /**
 2      * try{} --> catch(){return;} --> finally{return;}
 3      * @return
 4      */
 5     static Integer f5(){
 6         try {
 7             System.out.println("情况5try");
 8             //int a = 1/0;
 9         }catch (Exception e){
10             System.out.println("情况5catch");
11             return 1;
12         }finally {
13             System.out.println("情况5finally");
14             return 2;
15         }
16     }

无异常：

有异常：

例6、try{ return;} --> catch(){return;} --> finally{return;}

程序执行try块中return之前（包括return语句中的表达式运算）代码；

有异常：执行catch块中return之前（包括return语句中的表达式运算）代码；

则再执行finally块，因为finally块中有return所以提前退出。

无异常：则再执行finally块，因为finally块中有return所以提前退出。

 1 /**
 2      * try{ return;} --> catch(){return;} --> finally{return;}
 3      * @return
 4      */
 5     static Integer f6(){
 6         try {
 7             System.out.println("情况6try");
 8             //int a = 1 / 0;
 9             return 1;
10         }catch (Exception e){
11             System.out.println("情况6catch");
12             return 2;
13         }finally {
14             System.out.println("情况6finally");
15             return 3;
16         }
17     }

无异常：

有异常：

二、结论

1、不管有没有出现异常，finally块中代码都会执行；

2、当try和catch中有return时，finally仍然会执行；

3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，不管finally中的代码怎么样，返回的值都不会改变，任然是

之前保存的值），所以函数返回值是在finally执行前确定的；

4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

最终结论：任何执行try 或者catch中的return语句之前，都会先执行finally语句，如果finally存在的话。如果finally中有return语句，那么程序就return了，所以finally中

的return是一定会被return的，编译器把finally中的return实现为一个warning。

三、测试用例

  1 package exception;
  2 
  3 /**
  4  * @author zsh
  5  * @company wlgzs
  6  * @create 2019-03-01 10:32
  7  * @Describe 测试用例
  8  * 有return的情况下try catch finally的执行顺序
  9  *
 10  */
 11 public class Main1 {
 12 
 13     /**
 14      * 例1、try{} -->   catch(){} --> finally{} -->  return;
 15      */
 16     static Integer f1(){
 17         try {
 18             System.out.println("情况1try");
 19         }catch (Exception e){
 20             System.out.println("情况1catch");
 21         }finally {
 22             System.out.println("情况1finally");
 23         }
 24         return 0;
 25     }
 26 
 27     /**
 28      * try{ return; } --> catch(){}  --> finally{}  --> return;
 29      * @return
 30      */
 31     static Integer f2(){
 32         try {
 33             System.out.println("情况2try");
 34             return 1;
 35         }catch (Exception e){
 36             System.out.println("情况2catch");
 37         }finally {
 38             System.out.println("情况2finally");
 39         }
 40         return 0;
 41     }
 42 
 43     /**
 44      * try{ } --> catch(){return;}  --> finally{} --> return;
 45      * @return
 46      */
 47     static Integer f3(){
 48         try {
 49             System.out.println("情况3try");
 50             int a = 1/0;
 51         }catch (Exception e){
 52             System.out.println("情况3catch");
 53             return 1;
 54         }finally {
 55             System.out.println("情况3finally");
 56         }
 57         return 0;
 58     }
 59 
 60     /**
 61      * try{ return; } --> catch(){} --> finally{return;}
 62      * @return
 63      */
 64     static Integer f4(){
 65         try {
 66             System.out.println("情况4try");
 67             return 1;
 68         }catch (Exception e){
 69             System.out.println("情况4catch");
 70         }finally {
 71             System.out.println("情况4finally");
 72             return 2;
 73         }
 74     }
 75 
 76     /**
 77      * try{} --> catch(){return;} --> finally{return;}
 78      * @return
 79      */
 80     static Integer f5(){
 81         try {
 82             System.out.println("情况5try");
 83             int a = 1/0;
 84         }catch (Exception e){
 85             System.out.println("情况5catch");
 86             return 1;
 87         }finally {
 88             System.out.println("情况5finally");
 89             return 2;
 90         }
 91     }
 92 
 93     /**
 94      * try{ return;} --> catch(){return;} --> finally{return;}
 95      * @return
 96      */
 97     static Integer f6(){
 98         try {
 99             System.out.println("情况6try");
100             int a = 1 / 0;
101             return 1;
102         }catch (Exception e){
103             System.out.println("情况6catch");
104             return 2;
105         }finally {
106             System.out.println("情况6finally");
107             return 3;
108         }
109     }
110 
111     public static void main(String[] args) {
112         System.out.println("----------------------------");
113         System.out.println(f1());
114         System.out.println("----------------------------");
115         System.out.println(f2());
116         System.out.println("----------------------------");
117         System.out.println(f3());
118         System.out.println("----------------------------");
119         System.out.println(f4());
120         System.out.println("----------------------------");
121         System.out.println(f5());
122         System.out.println("----------------------------");
123         System.out.println(f6());
124         System.out.println("----------------------------");
125     }
126 
127 }