public class OutterTest
{
    public static void main(String[] args)
    {
            Outter out = new Outter();
            out.show(11);
    }
}
class Outter
{
    public void show(final int a)
    {
            class Inner
            {
                    public void show1()
                    {
                            System.out.println(a);
                    }
            }
            new Inner().show1();
    }
}
为什么在方法内的类只能访问带final的局部变量呢？

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

因为内部内是一个类,是在堆内存里,创建对象也在堆内存,在内部内访问方法的局部变量就是栈内存的局部变量,用堆内存的数据去访问栈内存的数据是访问不到的,因为堆内存比栈内存存活时间长,所以必须加上final，加上之后则变量就变成常量,常量是放在常量池也在堆内存,所以存活时间一样长.

1. 
   
2. public class OutterTest
   
3. {
   
4.     public static void main(String[] args)
   
5.     {
   
6.             Outter out = new Outter();
   
7.             out.show(11);
   
8.     }
   
9. }
   
10. class Outter
    
11. {
    
12.     public void show(final int a)
    
13.     {
    
14.             class Inner
    
15.             {
    
16.                     public void show1()
    
17.                     {
    
18.                             System.out.println(a);
    
19.                     }
    
20.             }
    
21.             new Inner().show1();
    
22.     }
    
23. }
    
24. 为什么在方法内的类只能访问带final的局部变量呢？

复制代码

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

O了，同志们给的太好了，理解了，谢谢了啊