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

先复习一个小知识点：

运行结果为：2

运行结果为：3

其实大家只要记住一句话就可以了，前++是先自加再使用而后++是先使用再自加！

------------------------------------------------------------------------------------------------

好了，接着继续try/catch finally，先看结论：

一、不管有没有出现异常，finally块中代码都会执行；
二、当try和catch中有return时，finally仍然会执行；
三、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，不管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；
四、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

情况1：try{} catch(){}finally{} return;

            显然程序按顺序执行。     

public class FinallyTest {
	static int test()
	{
		int x=2;
		try {
			x = x++;
		} catch (Exception e) {
           System.out.println("捕获异常");
		}finally{
			
		}
		return x;
	}
	public static void main(String[] args) {	 
		System.out.println(FinallyTest.test());
	}			
}

运行结果为: 2

情况2:try{ return; }catch(){} finally{} return;

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

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

public class FinallyTest {
	static int test()
	{
		int x=2;
		try {
			x = x++;
			return x;
		} catch (Exception e) {
           System.out.println("捕获异常");
		}finally{
			
		}
		return x+5;
	}
	public static void main(String[] args) {	 
		System.out.println(FinallyTest.test());
	}			
}

运行结果为： 2

再看下面这一段代码

public class FinallyTest {
	static int test()
	{
		int x=2;
		try {
			x = x++;
			return x;
		} catch (Exception e) {
           System.out.println("捕获异常");
		}finally{
			 System.out.println("执行finally代码块");
			 x=x+3;
		}
		 System.out.println("会打印出来吗？猜猜看");
		 int a =12;
		 System.out.println("会打印出来吗？猜猜看"+a);
		return x+5;
	}
	public static void main(String[] args) {	 
		System.out.println(FinallyTest.test());
	}			
}

运行结果为：
执行finally代码块
2

可以看到finally之后的代码并未执行。

情况3:try{ } catch(){return;} finally{} return;
         程序先执行try，分两种情况：有异常、无异常

  有异常：则执行catch中return之前（包括return语句中的表达式运算）代码，再执行finally语句中全部代码， 最后执行catch块中return. finally之后也就是4处的代码不再执行。

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

public class FinallyTest {  
    static int test()  
    {  
        int x=2;  
        try {  
            x++;
        } catch (Exception e) {  
           System.out.println("捕获异常"+e);  
           return x;
        }finally{  
        	 System.out.println("执行finally代码块");   
        }  
            return x;  
    }  
    public static void main(String[] args) {       
        System.out.println(FinallyTest.test());  
    }             
}  

执行结果如下：

执行finally代码块
3

情况4:try{ return; }catch(){} finally{return;}
          程序执行try块中return之前（包括return语句中的表达式运算）代码；

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

运行结果如下：

11

当finall块中包含return语句时，Eclipse会给出警告“finally block does not complete normally”，原因分析如下：

1、不管try块、catch块中是否有return语句，finally块都会执行。
2、finally块中的return语句会覆盖前面的return语句（try块、catch块中的return语句），所以如果finally块中有return语句，Eclipse编译器会报警告“finally block does not complete normally”。

3、如果finally块中包含了return语句，即使前面的catch块重新抛出了异常，则调用该方法的语句也不会获得catch块重新抛出的异常，而是会得到finally块的返回值，并且不会捕获异常。

结论，应避免在finally块中包含return语句。如果你在前面的语句中包含了return语句或重新抛出了异常，又在finally块中包含了return语句，说明你概念混淆，没有理解finally块的意义。

情况5:try{} catch(){return;}finally{return;}
          程序执行catch块中return之前（包括return语句中的表达式运算）代码；

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

public class FinallyTest {  
	static int test()  
    {  
        int x=2;  
        try {  
            x++; 
            throw new NullPointerException();
        } catch (Exception e) {  
           System.out.println("捕获异常"+e);  
           return x+3;
        }finally{  
              x=x+8;
              return x;  
        }  
    }  
    public static void main(String[] args) {       
        System.out.println(FinallyTest.test());  
    }             
} 

运行结果如下：

捕获异常java.lang.NullPointerException
11

情况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。