局部内部类如何访问局部变量？？
求详解，希望有图有真相。
问的不是用final修饰的变量。
如何调用不用final修饰的变量？？？

1.     class Outer   
   
2.     {
   
3.         int score = 95;
   
4.         void inst(final int s)
   
5.         {
   
6.             final int temp = 20 ;//使用final关键字定义局部变量
   
7.             class Inner
   
8.             {
   
9.                 void display()
   
10.                 {
    
11.                     System.out.println("成绩: score = " + (score+s+temp));
    
12.                 }
    
13.             }
    
14.             Inner in = new Inner();
    
15.             in.display();
    
16.         }
    
17.     }
    
18.     public class InnerClassDemo5
    
19.     {
    
20.         public static void main(String[] args)
    
21.         {
    
22.             Outer outer = new Outer();
    
23.             outer.inst(5) ;
    
24.         }
    
25.     }
    
26. 
    

复制代码

在方法中定义的内部类只能访问方法中的final类型的局部变量，
因为用final定义的局部变量相当于一个常量，它的生命周期超出方法运行的生命周期。
不用final定义变量temp的情况：内部类可以访问final标记的变量s，却无法访问在方法内部声明的变量temp

使用final定义temp后能够顺利编译，运行结果如下

局部内部类： 即在方法中定义的内部类，与局部变量类似，在局部内部类前不加修饰符public或private，其范围为定义它的代码块。
注意：局部内部类中不可定义静态变量，可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的。

再举个例子吧：

public class Outer {
private int s = 100;
private int out_i = 1;
public void f(final int k){
  final int s = 200;
  int i = 1;
  final int j = 10;
  class Inner{ //定义在方法内部
   int s = 300;//可以定义与外部类同名的变量
   //static int m = 20;//不可以定义静态变量
   Inner(int k){
    inner_f(k);
   }
   int inner_i = 100;
   void inner_f(int k){
    System.out.println(out_i);//如果内部类没有与外部类同名的变量，在内部类中可以直接访问外部类的实例变量
    System.out.println(k);//*****可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的*****
//    System.out.println(i);
    System.out.println(s);//如果内部类中有与外部类同名的变量，直接用变量名访问的是内部类的变量
    System.out.println(this.s);//用"this.变量名" 访问的也是内部类变量
    System.out.println(Outer.this.s);//用外部"外部类类名.this.变量名" 访问的是外部类变量
   }
  }
  new Inner(k);
}
public static void main(String[] args) {
//访问局部内部类必须先有外部类对象
  Outer out = new Outer();
  out.f(3);
}
}

java要求所有被局部内部类访问的局部变量都是用final修饰是因为：对于普通局部变量他的作用域就是该方法内，当方法结束该局部变量就随之消失；但局部内部类可能产生隐式的“闭包”，闭包将使得局部变量脱离他所在的方法继续存在。请看下面的例子是局部变量脱离他所在的方法继续存在的例子：

1. class Outter {
   
2.        
   
3.         public void inerTest(){
   
4.                 final int b = 23;   //定义的局部变量
   
5.                 class InnerClass{
   
6.                         public void print(){
   
7.                                 System.out.println("b="+b);        //此处将一直可以访问到b局部变量
   
8.                         }
   
9.                 }
   
10.                 InnerClass iner = new InnerClass();
    
11.                 iner.print();
    
12.         }
    
13.        
    
14. }
    
15. public class TestInerClass{
    
16.         public static void main(String ags[]){
    
17.                 Outter t = new Outter();
    
18.                 t.inerTest();
    
19.         }
    
20. }

复制代码

由于内部类可能扩大局部变量的作用域，如果这里没有加上final修饰，那么这里的局部变量就可以随时被改变，那样就可能混乱，因此java编译器要求所有被内部类访问的局部变量必须使用final修饰符修饰。

陈冲 发表于 2012-7-18 15:10
在方法中定义的内部类只能访问方法中的final类型的局部变量，
因为用final定义的局部变量相当于一个常量， ...

final这个知道，怎么调用变量

陈冲 发表于 2012-7-18 15:10
在方法中定义的内部类只能访问方法中的final类型的局部变量，
因为用final定义的局部变量相当于一个常量， ...

问的不是用final修饰的变量。
如何调用不用final修饰的变量？？？

陈冲 发表于 2012-7-18 15:10
在方法中定义的内部类只能访问方法中的final类型的局部变量，
因为用final定义的局部变量相当于一个常量， ...

问的不是用final修饰的变量。
如何调用不用final修饰的变量？？？