1. class Outer
   
2. {
   
3.         int x =1;//外部成员变量
   
4. 
   
5.         void show()
   
6.         {
   
7.                 final int x = 2;//外部类的局部变量
   
8.                 class Inter
   
9.                 {
   
10.                         int x=3;//内部局部类中的成员变量
    
11.                         void show_1()
    
12.                         {
    
13.                                 System.out.println("局部内部类访问外部类:::"+Outer.this.x);//局部内部类可以直接访问外部类
    
14.                                 
    
15.                                 /*
    
16.                                         问：怎么访问外部类的局部变量x= 2呢?
    
17.                                 */
    
18.                                 
    
19.                         }
    
20.                         
    
21.                 }
    
22.                 new Inter().show_1();
    
23.         }
    
24. }
    

复制代码

1. class Outer{
   
2.         int x = 3;
   
3.         private class Inner{
   
4.                 int x = 2;
   
5.                 void function(){
   
6.                         int x = 1;
   
7.                         System.out.println("innner"+x);
   
8.                         System.out.println("innner"+this.x);
   
9.                         System.out.println("innner"+Outer.this.x);
   
10.                 }
    
11.         }
    
12.         void method(){
    
13.                 Inner in = new Inner();
    
14.                 in.function();
    
15.         }
    
16. }
    
17. class InnerClassDemo{
    
18.         public static void main(String[] args) {
    
19.                 Outer out = new        Outer();
    
20.                 out.method();
    
21.         }
    
22. }

复制代码

如上代码，结果为1,2,3
原因  就近原则，当没有明确标出x所属对象获方法就就近当表明了所属对象或方法就是对应对象或方法的了

楼上回复跟lz问的不是一个事啊~lz问的是内部类访问已带有final的外部类的方法中的局部变量...
我觉得访问不到外部类的局部变量x，等着看大神解答....

通过.this关键字获取那个类的句柄，.this只对内部类有效，

我感觉不能访问到，请指点

1. public class Test3 {
   
2. 
   
3.         public static void main(String[] args){
   
4.                 // TODO Auto-generated method stub
   
5.                 new Outer().show();
   
6.         }
   
7. 
   
8. }
   
9. 
   
10. class Outer{
    
11.         int x = 1;
    
12.         void show(){
    
13.                 final int x =2;
    
14.                 //System.out.println(x);
    
15.                 class Inner{
    
16.                         int x = 3;
    
17.                        
    
18.                         void show_1(){
    
19.                                 //访问的是类Inner中的变量x=3
    
20.                                 System.out.println(x);
    
21.                                 //this指的是new Inner 同样打印的是类Inner中的x=3
    
22.                                 System.out.println(this.x);
    
23.                                 //打印的是Outer中的变量x=1
    
24.                                 System.out.println(Outer.this.x);
    
25.                                
    
26.                                 //要访问final int x = 2;
    
27.                                 //是函数嵌套中变量的调用，和如下函数之间的访问一样
    
28.                                 /*public static void main(String[] args) {
    
29. 
    
30.                                         void function1(){
    
31.                                                 int x = 1;
    
32.                                                 void function2(){
    
33.                                                         int x = 2;
    
34.                                                         System.out.println(x);
    
35.                                                 }
    
36.                                         }*/
    
37.                                 //输出的是最近作用域的x值       
    
38.                         }
    
39.                 }
    
40.                 new Inner().show_1();
    
41.         }
    
42. }

复制代码