匿名内部类为什么用final（为什么匿名内部类只能访问其所在方法中的final类型的局部变量）

本文目录

• 为什么匿名内部类只能访问其所在方法中的final类型的局部变量
• 为什么 线程里面的变量必须是final
• java：疑问出现在注释对应的代码：1.类对象为啥final修饰2.匿名内部类不大了解，接口不能用new对象吧
• java为什么匿名内部类的参数引用时final
• 匿名内部类访问局部变量 为什么final
• 用数组的形式为什么匿名内部类可以修改局部变量的值，而且前面也用final修饰了
• 为什么匿名内部类方法参数要使用final
• 为什么匿名内部类只能访问外部类 final修饰的变量

为什么匿名内部类只能访问其所在方法中的final类型的局部变量

1. 这里所说的“匿名内部类”主要是指在其外部类的成员方法内定义的同时完成实例化的类，若其访问该成员方法中的局部变量，局部变量必须要被final修饰。原因是编译器实现上的困难：内部类对象的生命周期很有可能会超过局部变量的生命周期。
2. 局部变量的生命周期：当该方法被调用时，该方法中的局部变量在栈中被创建，当方法调用结束时，退栈，这些局部变量全部死亡。而内部类对象生命周期与其它类对象一样：自创建一个匿名内部类对象，系统为该对象分配内存，直到没有引用变量指向分配给该对象的内存，它才有可能会死亡（被JVM垃圾回收）。所以完全可能出现的一种情况是：成员方法已调用结束，局部变量已死亡，但匿名内部类的对象仍然活着。
3. 如果匿名内部类的对象访问了同一个方法中的局部变量，就要求只要匿名内部类对象还活着，那么栈中的那些它要所访问的局部变量就不能“死亡”。
4. 解决方法：匿名内部类对象可以访问同一个方法中被定义为final类型的局部变量。定义为final后，编译器会把匿名内部类对象要访问的所有final类型局部变量，都拷贝一份作为该对象的成员变量。这样，即使栈中局部变量已经死亡，匿名内部类对象照样可以拿到该局部变量的值，因为它自己拷贝了一份，且与原局部变量的值始终保持一致（final类型不可变）。

为什么 线程里面的变量必须是final

为什么在匿名内部类中引用外部对象要加final修饰符呢，因为，在匿名内部类中引用的外部对象受到外部线程的作用域的制约有其特定的生命周期，以线程为例，当外部的变量生命周期已经完结之后，内部的线程还在运行，怎么样解决这个外部生命周期已经结束而在内部却需要继续使用呢，这个时候就需要在外部变量中添加final修饰符，其实内部匿名类使用的这个变量就是外部变量的一个“复制品”，即使外部变量生命周期已经结束，内部的“复制品“依然可用。

java：疑问出现在注释对应的代码：1.类对象为啥final修饰2.匿名内部类不大了解，接口不能用new对象吧

 1：为啥匿名内部类访问外部类局部变量要是final的。 
 简单来说就是为了防止你这个内部类所调用的局部变量因为非此内部类操作改变了值。
 你想想外部类的一个局部变量不定义final。内部类在用它，内部类没有方法对这个变量操作 ，而外部类或者其他内部类操作了它改变了数值，那么对内部类A来说不是很郁闷吗。。。内部  类A根本没有操作它却改变了数值。
2:接口本身是不能使用New 的.. 而是子类的对象,指向父类的引用是能使用new的..
比如说:
接口 intefaces=new 子类对象();   ---》正确;(你的代码却是这种)..
接口 intefaces=new 接口();          ---》这样肯定是错误的.. 
 new ActionListener() 是创建一个继承自ActionListener的匿名类对象，通过new表达式返回的引用自动向上转型为对ActionListener的引用。
因为匿名类本身无名，也就不存在构造方法，需要显式调用父类的构造方法，并重写父类的方法.。

java为什么匿名内部类的参数引用时final

内部类里面使用外部类的局部变量时，其实就是内部类的对象在使用它，内部类对象生命周期中都可能调用它，而内部类试图访问外部方法中的局部变量时，外部方法的局部变量很可能已经不存在了，那么就得延续其生命，拷贝到内部类中，而拷贝会带来不一致性，从而需要使用final声明保证一致性。

匿名内部类访问局部变量 为什么final

final修饰符对变量来说，深层次的理解就是保障变量值的一致性。为什么这么说呢？因为引用类型变量其本质是存入的是一个引用地址，说白了还是一个值（可以理解为内存中的地址值）。用final修饰后，这个这个引用变量的地址值不能改变，所以这个引用变量就无法再指向其它对象了。
回到正题，为什么需要用final保护数据的一致性呢？
因为将数据拷贝完成后，如果不用final修饰，则原先的局部变量可以发生变化。这里到了问题的核心了，如果局部变量发生变化后，匿名内部类是不知道的（因为他只是拷贝了局不变量的值，并不是直接使用的局部变量）。这里举个栗子：原先局部变量指向的是对象A，在创建匿名内部类后，匿名内部类中的成员变量也指向A对象。但过了一段时间局部变量的值指向另外一个B对象，但此时匿名内部类中还是指向原先的A对象。那么程序再接着运行下去，可能就会导致程序运行的结果与预期不同。

用数组的形式为什么匿名内部类可以修改局部变量的值，而且前面也用final修饰了

数组类型的变量是引用类型，final影响的是isFinish，作用是使isFinish只能被赋值一次，即isFinish一旦引用了某个数组对象，就不能再改为引用另一个数组对象。
即：
final boolean isFinish={false};
是允许的，而再赋值：
isFinish=new boolean {true};
是不允许的。
但isFinish引用的原数组对象的元素是可以修改的，即：
isFinish=true;
是可以的。

为什么匿名内部类方法参数要使用final

　　基础语法：如果定义一个匿名内部类，并且希望它使用一个在其外部定的对象，那么编译器会要求其参数引用是final的。
　　1.匿名内部类肯定是局部内部类(在一个方法里面定义的内部类)，因为在java中，语句必须写在方法里，而匿名内部类其实就是一条特殊的语句;
　　2.外部给定的对象就是所有外来的对象：外部方法的形参、局部变量、基本类型或自定义类型等。
　　3.内部类很微妙，它可以直接访问外部类的private　field，这打破了类的封装。但是内部类又有它自身的好处，比如简洁，可见性等，于是就把它定位成“只读”，也就是final。不过这个保护也非常脆弱!
　　4.local inner class访问local var时，那个var必须是final的。因为可以通过enclosing class访问那个local var，也可以通过inner class访问，可能造成问题，所以就必须是final的
　　5.匿名内部类为什么只能用final.是变量的作用域的问题，因为匿名内部类是出现在一个方法的内部的，如果它要访问这个方法的参数或者方法中定义的变量，则这些参数和变量必须被修饰为final。因为虽然匿名内部类在方法的内部，但实际编译的时候，内部类编译成Outer.Inner,这说明内部类所处的位置和外部类中的方法处在同一个等级上，外部类中的方法中的变量或参数只是方法的局部变量，这些变量或参数的作用域只在这个方法内部有效。因为编译的时候内部类和方法在同一级别上，所以方法中的变量或参数只有为final，内部类才可以引用。
　　6.例子
　　public class LocalInnerClassTest{
　　public static void main(String args){
　　Outer obj=new Outer(); //生成一个外部类对象
　　//调用外部类中的outer()方法，返回一个SuperInner类型对象赋值给si
　　SuperInner si=obj.outer();
　　si.m1(); //调用被覆盖的方法m1(),输出：Inner’s m1() 20
　　}
　　}
　　/**
　　*定义一个接口SuperInner，内部定义一个抽象方法m1(),无返回类型
　　*/
　　interface SuperInner{
　　public void m1();
　　}
　　/**
　　*定义一个类Outer，内部只定义一个方法outer()，返回类型为SuperInner
　　*/
　　class Outer{
　　public SuperInner outer(){
　　int a=10; //方法中定义一个局部变量a，并赋值为10
　　final int b=20; //再定义一个final局部变量b，初始化为20
　　//在outer()方法中定义一个局部内部类Inner,实现接口SuperInner
　　class Inner implements SuperInner{
　　public void m1(){ //类中只有一个覆盖接口SuperInner的方法m1()
　　System.out.println("Inner’s m1()"+a); //编译报错
　　//编译通过，输出：Inner’s m1() 20
　　System.out.println("Inner’s m1() "+b);
　　}
　　}
　　return new Inner();
　　}
　　}
　　我们先从主方法开始看代码的执行顺序，先生成一个Outer类对象obj，obj调用本类中方法outer();程序开始跳到outer()方法内执行程序语句，先后生成局部变量a和b,再定义一个局部内部类Inner，返回一个SuperInner类型的对象。将返回的SuperInner类型对象地址传给SuperInner类型对象si。si再调用m1()方法，因为已经在局部内部类中覆盖了接口中的m1()方法，所以将调用局部内部类中的m1() 方法，程序跳到局部内部类中m1()方法内执行程序语句，先输出一段字符串和a，结果编译报错，先 将这条程序语句隐藏，执行下面的语句，你会发现编译通过而且输出Inner’s m1() 20!
　　为什么会这样呢?大家都知道局部变量仅仅在一个范围内有效，在方法调用完就被内存释放，在Outer类对象obj调用outer()方法时，a和b才产生，调用结束后被内存释放，那么b这个值也就不复存在了，为什么还会输出20呢?难道局部变量被final修饰就不会被内存释放而保留?其实有部分操作对于程序员是透明的，那是JAVA语言开发者的小把戏，在定义a和b 时JVM(JAVA虚拟机)做了程序员看不到的操作，他将b拷贝了一份给局部内部类，也就是说JVM在局部内部类中定义了一个final int b=20;这个操作程序员是不知道的!当调用m1()方法时输出的20并不是原来outer()方法中定义的b，而仅仅是JVM拷贝的一个副本。那么为什么a没被打印出呢?那是因为JVM并没有拷贝它，因为没有final修饰，说明它可以被修改，如果把a 改为 a++，此时JVM就不知道拷贝a还是a++了，所以对于无final修饰的局部变量JVM是不会拷贝传给局部内部类的，自然无法打输出!

为什么匿名内部类只能访问外部类 final修饰的变量

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