1. 
   
2. public class Test
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 int c = fun();
   
7.                 System.out.println("c="+c);
   
8.         }
   
9.         public static int fun()
   
10.         {
    
11.                 int i = 1;
    
12.                 try
    
13.                 {
    
14.                         return ++i;
    
15.                 }finally
    
16.                 {
    
17.                         ++i;
    
18.                         System.out.println("i="+i);
    
19.                 }
    
20.         }
    
21. }
    

复制代码

finally不是在return的之前执行的么?可是结果好象不太对?
i是先打印的说明finally是先执行的,但是i的值怎么变为3了?
而c的值怎么又变回2了?
谁给解释下

分析：
一、finally是java异常处理机制的一个关键字，
      它的作用是：不论是否产生异常，此代码块中的语句都会被执行到，
      try块中执行完毕之后，会转入到finally语句块中。
      在try块中已经改变了i的值（为2），在finally里再次改变了i的值（为3），
      自然打印出的是i=3;
二、return表示的是这个方法结束，并返回一个值，此时它的值为2，在main函数中
      自然打印的是c=2,
三、ｉ＋＋：表示的是先运算后，再自加
      ＋＋ｉ：表示的是先自加，再参与运算。
可以看一下ｊａｖａ的异常捕获机制，可能对你有帮助。

在try语句中，在执行return语句时，要返回的结果其实已经准备好了，就在此时，程序转到finally执行了。

在转去之前，try中先把要返回的结果存放到不同于x的局部变量中去，执行完finally之后，在从中取出返回结果，

因此，即使finally中对变量x进行了改变，但是不会影响返回结果。

换言之 finally里面操作了的是已经retun后的值！

一、如果try catch finally块均无return则执行最后finally外的return；
如果try catch finally中任何一个有return则最后finally外的return不再执行；

二、只要finally块中有return则try或catch中的return不再执行.
总结：任何调用try 或者catch中的return语句之前，都会先执行finally语句，如果finally存在的话。
建议楼主看下我的博客，关于这个问题写的非常详细
www.cnblogs.com/bin-study/

return什么时候写?? 这个还是要根据你的代码来定的,

当你什么时候需要return 就写return,  

try{  return "这里也可以"}
cath{ return " 这里也可以"}
finally{"这里 依旧可以.."},

执行的话, finally 不管你在有没有异常 , finally 里的语句 是必须执行的一个语句, 所以 先计算 finally 的语句

所以代码的执行顺序是这样的, int i =1;  ++i , i 等于2, return,  由于finally .. 执行下去, i = 3,  这是第1个打印,

然后c的值是因为第一次++i 的时候被return 这时候 i 等于=2... 于是打印出第2个值 c = 2;

public class Test
{
        public static void main(String[] args)
        {
                int c = fun();//此时c已经是2，由于被调用函数还没有执行完，所以没有执行下条语句打印
                System.out.println("c="+c);//被调用函数执行完，执行这条语句
        }

        public static int fun()
        {
                int i = 1;
                try
                {
                        return ++i;//先执行这条语句，运行到这里i已经是2，并且返回给调用函数
                }finally
                {
                        ++i;
                        System.out.println("i="+i);//这里i是3，并且打印
                }
        }//被调用函数，执行完
}

张云杰 发表于 2013-1-14 18:27
return什么时候写?? 这个还是要根据你的代码来定的,

当你什么时候需要return 就写return,  

是不是可以这样理解,执行到try的return时  main 函数已经拿到try中i的值?

return是在finally执行后才返回的，且在finally无法改变返回值

1. 
   
2. public class Test
   
3. {
   
4.         public static void main(String[] args)
   
5.         {
   
6.                 //在执行这句时，同时执行了finally语句
   
7.                 int c = fun();
   
8.                 System.out.println("c="+c);
   
9.         }
   
10.         public static int fun()
    
11.         {
    
12.                 int i = 1;
    
13.                 try
    
14.                 {
    
15.        [color=Red]         //++I是i先加1再return,自然此时i=2      [/color]  
    
16.                 return ++i;
    
17.                 }finally
    
18.                 {
    
19.                         //这时候。继续自加，于是i=3
    
20.                         ++i;
    
21.                         System.out.println("i="+i);
    
22.                 }
    
23.         }
    
24. }

复制代码

这个已经不是什么先执行后执行的问题了。而是有finally就必然执行，在执行int i = fun()的同时已经执行finally语句了，然后才有后面的System.out.println.......