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

复制代码

运行结果是1 ，而不是2 ， 张老师说finally 是在return中间执行是什么意思。不懂。

本来return后的语句就不可以执行了的。但是finally比较特殊，它在程序运行前就加载进内存，所以会在return前执行。

楼主你好，如果问题以解决，请修改分类，谢谢合作。

楼主你好，如果问题以解决，请修改分类，谢谢合作。

可以把以下代码拷贝运行一下，应该能理解清楚

package com.itheima;
/**
* 第6题： 写一个类证明return是在finally执行后才返回的，且在finally无法改变返回值。
* @author Administrator
*
*/
public class Test6 {
        public static void main(String[] args){
                  
                //创建FinallyDemo类对象
                FinallyDemo fd = new FinallyDemo();
               
                //定义整型变量接收fd调用函数show（）的返回值
            int x = fd.show();
            
            //输出x
                System.out.println("执行return，接收return返回值为       x="+x);
               
        }

}

//创建 FinallyDemo类
class FinallyDemo{
//定义类方法show（）
        int show(){
                //定义数组arr
                int[] arr ={0,1,2,3} ;
                int x=100;
               
                //通过try{}finally{}检测异常
                try{
                         x = arr[0];
                     System.out.println("执行到return语句之前");
                         return x;
                   }
               
                finally{
                        System.out.println("执行了fianlly语句");
                        x=9999;       
                       
                        //验证finally先于return执行，且在finally虽然能给x赋值，却改变不了返回值
                        System.out.println("在fianlly中给 变量x赋值之后                  x="+x);
                       
                }
        }
       
}

1. public class TestFinally {
   
2.         static int f(){
   
3.                 int i=1;
   
4.                 try {
   
5.                         System.out.println("try----"+i);
   
6.                         return i;
   
7.                 }
   
8.                 finally{
   
9.                         ++i;
   
10.                         System.out.println("finally---"+i);//返回的时候i的值没有变，函数返回后才执行的finally
    
11.                         
    
12.                 }
    
13.         }
    
14.         public static void main(String[] args){
    
15.                 System.out.println(f());
    
16.         }
    
17. }
    
18. /*
    
19. * try----1
    
20. * finally---2
    
21. * 1
    
22. */

复制代码

没有吧，这个结构，finally是无论有无发生异常，都会执行：++x；

因为，finally句其实相当初始化快，在程序运行之前，就会先加载进内存，故“++x”会先于return之前执行，最会返回的值自然是"x+1"后的值。