1. 
   
2. class Outer
   
3. {
   
4.         int x=3;
   
5.         void method()
   
6.         {
   
7.                 final int y=4//为什么？原因，
   
8.                 class Inner//内部类处于局部中。不能被成员修饰符修饰
   
9.                 {
   
10.                         void function()
    
11.                         {
    
12.                                 System.out.println(y);//内部类访问局部变量需要最终
    
13.                         }
    
14.                 }
    
15.         }
    
16. }
    
17. 
    
18. class InnerDemo4
    
19. {
    
20.         public static void main(String [] args)
    
21.         {
    
22.                 new Outer().method();       
    
23.         }
    
24. }
    

复制代码

局部内部类访问该方法中的局部变量是，该局部变量必须是final的。成员修饰符是修饰成员的，局部内部类已经不在成员位置，所以是不能被成员修饰符修饰的。

主要还是生命周期的问题，内部类的生命周期要比局部变量长，同在一个方法内，方法结束，局部变量的生命周期也结束了，那么局部变量自然在栈内存中被释放
但是方法内的内部类却不会结束，它仍然存在于堆内存。
而final修饰的常量的生命周期很长，就可以被内部类访问了

老兄你这个代码创建内部类的意义都没有啊

1. class Outer{       
   
2.         public Object get(){
   
3.                 int x = 1;
   
4.                 class Inner{
   
5.                         public int hashCode() {                                                       
   
6.                                 return x ;
   
7.                         }
   
8.                 }
   
9.                 Inner in = new Inner();
   
10.                 return in;
    
11.         }
    
12. }
    
13. public class PropTest {
    
14.         public static void main(String[] args) {
    
15.                 Object o = new Outer().get();
    
16.                 System.out.println(o.hashCode());
    
17.         }
    
18. }

复制代码

我给你写了个代码你看一下
创建Outer对象，调用get方法，获取了Object对象，这时get方法弹栈，没有加final的x也弹栈，主函数又调用了hashcode方法，方法中要访问x，此时x已经不在了 就不能访问
我这里写hashcode方法时覆盖了Object的hashcode，只是为了方便。
final其实虚拟机将修饰的那个变量储存到了内部类中

class Outer

{

       int x=3;
       void method()
       {

         final int y=4  ;  //因为局部内部类是定义在方法当中，只能访问方法中声明的final 类型的变量。              
  class Inner   //因为定义内部类的目的就是不让其它类去访问它  ，如果用成员修饰符修饰那不就违背它的本意了吗
             {

                     void function()
                      {
                               System.out.println(y);

                      }
             }
       }

}


class InnerDemo4

{

       public static void main(String [] args)
     {
              new Outer().method();        

    }
}