Java的局部内部类以及final类型的参数和变量

转自  http://xm-king.iteye.com/blog/773292

Thinking In Java里面的说法（唯一正确的说法）： 如果定义一个匿名内部类，并且希望它使用一个在其外部定的对象，那么编译器会要求其参数引用是final 的。

Java代码  

1. public class Tester {      
2.        public static void main(String[] args) {      
3.        A a = new A();      
4.        C c = new C();      
5.        c.shoutc(a.shout(5));      
6.     }      
7. }      
8. ///      
9. class A {      
10.     public void shouta() {      
11.        System.out.println("Hello A");      
12.     }      
13.      
14.     public A shout(final int arg) {      
15.         class B extends A {      
16.             public void shouta() {      
17.                System.out.println("Hello B" + arg);      
18.            }      
19.        }      
20.         return new B();      
21.     }      
22. }      
23.       
24. class C {      
25.     void shoutc(A a) {      
26.         a.shouta();      
27.     }      
28. }     

 

      第5行c.shoutc(a.shout(5))，在a.shout(5)得到返回值后，a的shout()方法栈被清空了，即arg不存在了，而 c.shoutc()却又调用了a.shouta()去执行System.out.println("Hello B" + arg)。
       再来看Java虚拟机是怎么实现这个诡异的访问的：有人认为这种访问之所以能完成，是因为arg是final的，由于变量的生命周期，事实是这样的吗？方法栈都不存在了，变量即使存在，怎么可能还被访问到？试想下：一个方法能访问另一个方法的定义的final局部变量吗(不通过返回值)？
       研究一下这个诡异的访问执行的原理，用反射探测一下局部内部类 。编译器会探测局部内部类中是否有直接使用外部定义变量的情况，如果有访问就会定义一个同类型的变量，然后在构造方法中用外部变量给自己定义的变量赋值，而后局部内部类所使用的变量都是自己定义的变量，所以就可以访问了。见下： 

Java代码  

1. class   A$1$B  {    
2.     A$1$B(A,   int);    
3.     private   final   int   var$arg;    
4.     private   final   A   this$0;    
5. }    

      A$1$B类型的对象会使用自定义的var$arg变量，而不是shout()方法中的final int arg变量，当然就可以访问了。
       那么为什么外部变量要是final的呢？即使外部变量不是final，编译器也可以如此处理：自己定义一个同类型的变量，然后在构造方法中赋值就行了。原因就是为了让我们能够挺合逻辑的直接使用外部变量，而且看起来是在始终使用　外部的arg变量(而不是赋值以后的自己的字段)。
       考虑出现这种情况：在局部内部类中使用外部变量arg，如果编译器允许arg不是final的，那么就可以对这个变量作变值操作（例如 arg++），根据前面的分析，变值操作改变的是var$arg，而外部的变量arg并没有变，仍然是5(var$arg才是6)。因此为了避免这样如此不合逻辑的事情发生：你用了外部变量，又改变了变量的值，但那个变量却没有变化，自然的arg就被强行规定必须是final所修饰的，以确保让两个值永远一样，或所指向的对象永远一样（后者可能更重要)。
       将函数的参数引用设为final，主要是考虑到局部变量的生命周期与局部内部类的对象的生命周期的不一致性!往深层次说，就是为了解决参数的不一致性问题。即 因为从编程人员的角度来看他们是同一个东西， 如果编程人员在程序设计的时候在内部类中改掉参数的值，但是外部调用的时候又发现值其实没有被改掉，这就让人非常的难以理解 和接受，为了避免这种尴尬的问 题存在，所以编译器设计人员把内部类能够使用的参数设定为必须是final来规避这种莫名其妙错误的存在。

       举个例子来说可能会更清楚一些，对于局部变量int i=3;方法中代码修改的是这个真正的变量i,而内部为对象修改的是i的复制品copy_i，这样这两个i就会发生值的不一致性，（这一点正是这个实现技术的缺陷),所以干脆就不允许这个int i=3;局部变量发生值的改变!由于不允许改int i的值,所以这两个int i的值就始终保持值的一致了,这才是final的这个规定的由来! 是一种不得不如此的无奈之举!

      简单的来说，因为生命周期的原因，内部类需要复制局部变量为内部类的一个属性变量，因为复制，所以要将修饰符设为final。