finally块的问题(finally block does not complete normal

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

一、无论try块、catch块中是否有return语句，finally块都会执行。
二、finally块中的return语句会覆盖前面的return语句（try块、catch块中的return语句），因此若是finally块中有return语句，Eclipse编译器会报警告“finally block does not complete normally”。

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

 

结论，

finally 内部使用 return 语句是一种很很差的习惯，若是try中还有return语句，它会覆盖了try 区域中 return 语句的返回值，程序的可读性差

面对上述状况，其实更合理的作法是，既不在 try block 内部中使用 return 语句，也不在 finally 内部使用 return 语句，而应该在 finally 语句以后使用 return 来表示函数的结束和返回

 

 

 

结论：
一、无论有木有出现异常，finally块中代码都会执行；
二、当try和catch中有return时，finally仍然会执行；
三、finally是在return后面的表达式运算后执行的（此时并无返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是以前保存的值），因此函数返回值是在finally执行前肯定的；
四、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进行了改变，可是不会影响返回结果。
它应该使用栈保存返回值。

 

public class Ex1 {

    public static void main(String[] args) {
        System.out.println(Ex1.getResult());
    }

    public static int getResult(){
        int a =100;
        
        try{
            return a+10; //注意，java的基础数据类型是值传递，这里的返回值已经和上面的a没有关系了
        }catch(Exception e){

            e.printStackTrace();  
        }finally{
            return a;    //最后再把值重定向到a(至关于将try中的返回值覆盖掉)，因此输出仍是100
        }
    }
}

 再看一个例子：

 

public class Ex1 {

    public static void main(String[] args) {
        try{
        System.out.println(Ex1.getResult());
        }catch(Exception e){
            e.printStackTrace();
            System.out.println("截获异常catch");
        }finally{
            System.out.println("异常处理finally");
        }
    }

    public static int getResult() throws Exception{
        int a =100;
        
        try{
            
            a=a+10; 
            throw new RuntimeException();
        }catch(Exception e){
            System.out.println("截获异常并从新抛出异常");
            throw new Exception();            
        }finally{
            return a;
        }
    }
}

输出以下：

截获异常并从新抛出异常
110
异常处理finally
关键的“截获异常catch”却没有执行！！！

缘由是在getResult()的finally中return一个值，等同于告诉编译器该方法没有异常,但实际上异常是有的，这样的结果是该方法的调用者却捕获不到异常，相对于异常被无故的被吃掉了，隐藏杀机啊！！

结论：不要再finally中试图return一个值，这样可能会致使一些意想不到的逻辑错误，finally就是用来释放资源的！！