01.public class Anonymity {

02.

03.public static void main(String[] args) {

04.

05.         final int x = 10;//为什么一定要用final修饰

06.        

07.         Object obj = new Object(){               

08.                public String toString(){

09.                        return String.valueOf(x);                        

10.                }

11.        };

12.        System.out.println(obj);

13.        }

14.}

为什么一定要加final

1.匿名内部类肯定是局部内部类(在一个方法里面定义的内部类)，因为在java中，语句必须写在方法里，而匿名内部类其实就是一条特殊的语句；
2.外部给定的对象就是所有外来的对象：外部方法的形参、局部变量、基本类型或自定义类型等。
3.内部类很微妙，它可以直接访问外部类的ｐｒｉｖａｔｅ　ｆｉｅｌｄ，这打破了类的封装。但是内部类又有它自身的好处，比如简洁，可见性等，于是就把它定位成“只读”，也就是ｆｉｎａｌ。不过这个保护也非常脆弱！
4.local inner class访问local var时，那个var必须是final的。因为可以通过enclosing class访问那个local var，也可以通过inner class访问，可能造成问题，所以就必须是final的
5.匿名内部类为什么只能用final.是变量的作用域的问题，因为匿名内部类是出现在一个方法的内部的，如果它要访问这个方法的参数或者方法中定义的变量，则这些参数和变量必须被修饰为final。因为虽然匿名内部类在方法的内部，但实际编译的时候，内部类编译成Outer.Inner,这说明内部类所处的位置和外部类中的方法处在同一个等级上，外部类中的方法中的变量或参数只是方法的局部变量，这些变量或参数的作用域只在这个方法内部有效。因为编译的时候内部类和方法在同一级别上，所以方法中的变量或参数只有为final，内部类才可以引用。

1. public class LocalInnerClassTest{
   
2.      public static void main(String[] args){
   
3.         Outer obj=new Outer();       //生成一个外部类对象
   
4.        //调用外部类中的outer()方法，返回一个SuperInner类型对象赋值给si
   
5.         SuperInner si=obj.outer();                                      
   
6.         si.m1();                     //调用被覆盖的方法m1(),输出：Inner's m1() 20
   
7.      }
   
8. }
   
9. 
   
10. /**
    
11. *定义一个接口SuperInner，内部定义一个抽象方法m1(),无返回类型
    
12. */
    
13. interface SuperInner{
    
14.      public void m1();
    
15. }
    
16. 
    
17. /**
    
18. *定义一个类Outer，内部只定义一个方法outer()，返回类型为SuperInner
    
19. */
    
20. class Outer{
    
21.      public SuperInner outer(){
    
22.         int a=10;                //方法中定义一个局部变量a，并赋值为10
    
23.         final int b=20;          //再定义一个final局部变量b，初始化为20
    
24.       
    
25.         //在outer()方法中定义一个局部内部类Inner,实现接口SuperInner
    
26.         class Inner implements SuperInner{            
    
27.            public void m1(){    //类中只有一个覆盖接口SuperInner的方法m1()
    
28.               System.out.println("Inner's m1()"+a);    //编译报错
    
29.               //编译通过，输出：Inner's m1() 20
    
30.               System.out.println("Inner's m1() "+b);  
    
31.            }
    
32.         }
    
33.         return new Inner();
    
34.      }
    
35. }

复制代码

还有一个原因是，匿名内部类是对象了，对象的生命周期比局部变量长，当程序运行，出了方法体后，对象还存在着，可是局部变量却没了，那就不对了，所以要用final关键字修饰

final int x = 10;//为什么一定要用final修饰

final 修饰的是常量啦，在哪里都可以用！！！

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