在了解动态代理的时候，当在InvocationHander内部的实现类中 使用外部类的参数或者变量为什么必须是final类型的

sunhaodi 发表于 2012-6-27 14:46
是变量的作用域的问题，因为匿名内部类是出现在一个方法的内部的，如果它要访问这个方法的参数或者方法中 ...

:L  我已经告诉说是找的嘛，怎么还警告。。。  这么深的问题，我也想明白嘛，所以找一下，正好发上，让这个同学也看下，  晕倒。。。

刘蕴学 发表于 2012-6-28 15:26
还得我亲自出马。。。另外就是引用类型和基本类型在这里的表现是不一样的，你区分他们的话最好拿你自己定义 ...

貌似你很厉害。所以有个问题请求。
关于值传递和引用传递。百度上什么说的都有。还有就是java中是不是只有值传递啊。

还得我亲自出马。。。另外就是引用类型和基本类型在这里的表现是不一样的，你区分他们的话最好拿你自己定义的类来测试。

代码你自己跑吧，看不懂的话，我也木有办法了

1. 
   
2. 
   
3. import java.lang.reflect.Field;
   
4. 
   
5. 
   
6. public class NoFinalFieldCnnotUsedInner
   
7. {
   
8.         public static void main(String[] args)
   
9.         {
   
10.                 Outer outer = new Outer();
    
11.                 SuperInner inner = outer.outer();
    
12. //                inner.inner();
    
13.         }
    
14. }
    
15. /* 定义一个局部内部类的上层接口，用以允许返回局部内部类实例 */
    
16. interface SuperInner
    
17. {
    
18.         void inner();
    
19. }
    
20. /* 定义一个外部类，包括一个outer方法，用以返回局部内部类实例 */
    
21. class Outer
    
22. {
    
23.         int y = 0;
    
24.         //out方法将返回inner实例
    
25.         SuperInner outer()
    
26.         {
    
27.                 //假设我们这里x可以被inner访问，那么outer函数返回之后
    
28.                 //x已经被销毁，inner对象就无法访问x
    
29.                
    
30.                 //换句话说就是Inner对象的生存周期超出了x的边界，而能保证
    
31.                 //生存周期一致的情况只有inner对象自己的成员，所以通过在
    
32.                 //inner里边复制一个x来保存这个局部变量x的值以达到目的
    
33.                 //就像val$x一样
    
34.                
    
35.                 //但这种办法有个致命点，如果在inner里对val$x进行赋值操作
    
36.                 //外边的x并不会被改变，所以为了保证两个对象的一致性，该变量
    
37.                 //x以及其复制变量val$x必须为终态的，也就是final，不能再次
    
38.                 //赋值
    
39.                
    
40.                 //反编译inner可以证明以上结论，在字节码里
    
41. //                question6.Outer$1Inner(question6.Outer, java.lang.String)
    
42.                 //这是构造方法，传outer不奇怪，内部类都需要外部类的引用指针
    
43.                 //这个String字符串就值得思考了
    
44.                
    
45.                 //4 getfield val$y
    
46.                 //在inner方法中可以看到这个字节码，是val$y 而不是y
    
47.                 int x = 4;
    
48.                 final String y = new String("asd");
    
49.                 class Inner implements SuperInner
    
50.                 {
    
51. //                        int val$x = 4;
    
52.                         public void inner()
    
53.                         {
    
54.                                 try
    
55.                                 {
    
56.                                         //这里通过反射，可以发现证明此y非彼y，因为我们并没有
    
57.                                         //在inner里定义val$y变量，而我们却可以拿得到，没异常
    
58.                                         //而我们改的是val$y的值为qqq,下边的syso(y)居然会输出
    
59.                                         //qqq，结论可以证实
    
60.                                        
    
61.                                         //通过代码也可以看出来，这个val$y肯定是private的，并且
    
62.                                         //他也是final的
    
63.                                         Field field = getClass().getDeclaredField("val$y");
    
64.                                         field.setAccessible(true);
    
65.                                         System.out.println(y);
    
66.                                         field.set(Inner.this, "qqq");
    
67.                 }
    
68.                 catch (Exception e)
    
69.                 {
    
70.                         e.printStackTrace();
    
71.                 }
    
72. //                                System.out.println(x);本行编译报错，提示局部内部类访问必须是终态的
    
73.                                 System.out.println(y);//输出y的值
    
74.                         }
    
75.                 }
    
76.                 //奇怪么？打印3次y的结果居然是不一样的
    
77.                 //外部的局部y一直是asd
    
78.                
    
79.                 //内部输出的y是qqq，呵呵
    
80.                 Inner inner = new Inner();
    
81.                 inner.inner();
    
82.                 System.out.println(y);
    
83.                
    
84.                
    
85.                 //当inner实例被返回时，x将被销毁
    
86.                 return inner;
    
87.         }
    
88. }

复制代码

嗯 已经明白了

这个问题我在论坛里面看了N 遍~~~~~~~~请找一下类似帖子！同学！

定义带参数的局部类的方法结束的时候，内部类才刚开始运行，局部变量才开始使用。
但是局部变量会因为方法的不再使用而消失。
所以内部类在使用外部类的变量时必须用final类型的，以保证局部变量与在局部类建立时使用时一致！
否者会影响程序的运行！

是变量的作用域的问题，因为匿名内部类是出现在一个方法的内部的，如果它要访问这个方法的参数或者方法中定义的变量，则这些参数和变量必须被修饰为final。因为虽然匿名内部类在方法的内部，但实际编译的时候，内部类编译成Outer.Inner,这说明内部类所处的位置和外部类中的方法处在同一个等级上，外部类中的方法中的变量或参数只是方法的局部变量，这些变量或参数的作用域只在这个方法内部有效。因为编译的时候内部类和方法在同一级别上，所以方法中的变量或参数只有为final，内部类才可以引用。

Java代码:
package com.cxz.j2se;   
  
public class MyClass {   
    public MyClass() {   
        final int finalValue = 10;   
        int not$Final = 20;   
        MyInterface myInterface = new MyInterface() {   
            public void functionWithoutPara() {   
                //compile Error   
                //System.out.println(noFinal);   
                System.out.println(finalValue);   
            }   
  
            public void functionWithPara(int num) {   
                System.out.println("The parameter " + num   
                        + " has been passed by the method");   
            }   
  
        };   
        myInterface.functionWithoutPara();   
        myInterface.functionWithPara(not$Final);   
        System.out.println(myInterface.getClass().getName());   
    }   
  
    public static void main(String[] args) {   
        new MyClass();   
  
    }   
  
}  

二、为什么局部内部类只能访问final变量
简单的来说是作用域的问题。就好像方法外面做的事情并不能改变方法内才定义的变量，因为你并不知道方法里面这个时候已经存在了这个局部变量了没有。在这个内部类中方法里面的本地变量是失效的，也就是不在作用域内，所以是不能够访问的

但是为什么这里用final却又可以访问呢？
因为Java采用了一种copy   local   variable的方式来实现，也就是说把定义为final的局部变量拷贝过来用，而引用的也可以拿过来用，只是不能重新赋值。从而造成了可以access   local   variable的假象，而这个时候由于不能重新赋值，所以一般不会造成不可预料的事情发生

     首先方法中定义内部类，是为了控制这个类的可见性，编译之后，也会出现外部类和内部类各自的字节码,他们有各自的成员变量和方法。
其次方法和内部类的生命周期不同：前者执行完毕，方法内局部变量也会随之销毁，而此时再让内部类访问显然是不合理的。
而方法中的变量前加final，当某一属性加此关键词后就成为常量了，而常量的生命周期为程序的整个执行期间
所以方法内的类只能访问带final的局部变量

内部类并不是直接调用方法传进来的参数，而是内部类将传进来的参数通过自己的构造器备份到了自己的内部，自己内部的方法调用的实际是自己的属性而不是外部类方法的参数。
这样理解就很容易得出为什么要用final了，因为两者从外表看起来是同一个东西，实际上却不是这样，如果内部类改掉了这些参数的值也不可能影响到原参数，然而这样却失去了参数的一致性，因为从编程人员的角度来看他们是同一个东西，如果编程人员在程序设计的时候在内部类中改掉参数的值，但是外部调用的时候又发现值其实没有被改掉，这就让人非常的难以理解和接受，为了避免这种尴尬的问题存在，所以编译器设计人员把内部类能够使用的参数设定为必须是final来规避这种莫名其妙错误的存在

原因如下：

abstract class ABSClass{
public abstract void print();
}

public class Test2{
public static void test(final String s){//一旦参数在匿名类内部使用,则必须是final
ABSClass c=new ABSClass(){
public void print(){
System.out.println(s);
}
};
c.print();
}
public static void main(String[] args){
test("Hello World!");
}
}

JVM中每个进程都会有多个根,每个static变量,方法参数,局部变量,当然这都是指引用类型.基础类型是不能作为根的,根其实就是一个存储地址.垃圾回收器在工作时先从根开始遍历它引用的对象并标记它们,如此递归到最末梢,所有根都遍历后,没有被标记到的对象说明没有被引用,那么就是可以被回收的对象(有些对象有finalized方法,虽然没有引用,但JVM中有一个专门的队列引用它们直到finalized方法被执行后才从该队列中移除成为真正没有引用的对象,可以回收,这个与本主题讨论的无关,包括代的划分等以后再说明).这看起来很好.

但是在内部类的回调方法中,s既不可能是静态变量,也不是方法中的临时变量,也不是方法参数,它不可能作为根,在内部类中也没有变量引用它,它的根在内部类外部的那个方法中,如果这时外面变量s重指向其它对象,则回调方法中的这个对象s就失去了引用,可能被回收,而由于内部类回调方法大多数在其它线程中执行,可能还要在回收后还会继续访问它.这将是什么结果?

而使用final修饰符不仅会保持对象的引用不会改变,而且编译器还会持续维护这个对象在回调方法中的生命周期.所以这才是final变量和final参数的根本意义