1. class Outer
   
2. {
   
3.         private int x = 3;
   
4. 
   
5.         class Inner
   
6.         {
   
7.                 int x = 4;
   
8.                 void function()
   
9.                 {
   
10.                         int x = 7;
    
11.                         System.out.println("inner : "+x);//x 输出7  ;this.x输出4; Outer.this.x 输出4
    
12.                 }
    
13. 
    
14. 
    
15.         class Inner2//嵌套的嵌套
    
16.         {
    
17.                         void function2()
    
18.                         {
    
19.                         System.out.println("inner2 : "+x);//x输出4,
    
20.                         }                                       
    
21.         }
    
22.                         void method2()
    
23.                         {
    
24.                                 Inner2 x = new Inner2();
    
25.                                 x.function2();
    
26.                         }
    
27.         }                                
    
28. 
    
29.    void method()
    
30.    {
    
31.                 Inner in = new Inner();
    
32.                 in.function();
    
33.                 in.method2();
    
34.    }
    
35. 
    
36. }
    
37. 
    
38. 
    
39. 
    
40. class InnerClassDemo2
    
41. {
    
42.         public static void main(String[] args)
    
43.         {
    
44.                
    
45.                 Outer out= new Outer();
    
46.                
    
47.                 out.method();
    
48.                 //Outer.Inner o = new Outer().new Inner();
    
49.                 //o.function();
    
50.         }
    
51. }

复制代码

复习视频内部类,我在内部类里 又写了一个内部类 Inner2   想调用 Inner 里的 x=7  ;
在Inner里我用 Inner.this.x   和Outer.this.x 都指向的不是X=7  
想请教一下 怎样 在内部类inner2 中 输出x=7
谢谢了...代码写的不规范...请见谅

(黑马 我来了)

包晗 发表于 2012-7-17 09:30
地头蛇理论....我还真去百度了下......呵呵
差不多理解了

其实这个是我们当时C++老师将全局变量和局部变量说的，有没有我也不知道，就用了。。。找不到别纠结那个词。

樊佰轩 发表于 2012-7-17 08:32
x=7是函数void function()内的局部变量，在函数结束时自动销毁。在void类型函数外部是不可能获得并使用的数 ...

地头蛇理论....我还真去百度了下......呵呵
差不多理解了

int x=7;是定义在内部类Inner的成员方法function()中的局部变量，而不是Inner类的成员属性，其作用范围仅限于Inner的function()中。
若想在嵌套的内部类Inner2中调用x=7，只能通过Inner类的function()方法来调用。
调用方法如下：
class Inner2//嵌套的嵌套
        {
                        void function2()
                        {
                        System.out.println("inner2 : "+x);//x输出4
                        new Inner().function(); //这里的x将输出7
                        }                                       
        }
                        void method2()
                        {
                                Inner2 x = new Inner2();
                                x.function2();
                        }
        }           

x=7是函数void function()内的局部变量，在函数结束时自动销毁。在void类型函数外部是不可能获得并使用的数据，而根据“地头蛇理论”，在方法void function()中输出7。  int x = 4是类Inner的成员，可以被该类的方法和内部类使用，因此在void function2()中x=4的。

本人语言组织能力有限，尽量给你讲明白。。。

我的理解是
void function()//这是一个方法体，在内存中随着调用而产生，程序跑过了，就释放内存了。

09.                {

10.                        int x = 7;

11.                        System.out.println("inner : "+x);//x 输出7  ;this.x输出4; Outer.this.x 输出4

12.                }
所以，你想要在Inner2中输出x=7，按照你的意思，用简单的调用是不能实现的。

        int function()
                {
                        int x = 7;
                        //System.out.println("inner : "+x);//x 输出7  ;this.x输出4; Outer.this.x 输出4
            return x;
                }
                class Inner2//嵌套的嵌套
        {
                        void function2(){
                                System.out.println("inner2 : "+function());//此时输出7
                                }                                       

        }
不知道把方法体改成返回整型，是不是违背了你的初衷，这样的确可以输出7

将x=7的x换一个名称，放在Inner类全局变量的位置，就可以在inner2里得到7

1. class Outer {
   
2.         private int x = 3;
   
3.         class Inner {
   
4.                 int x = 4;
   
5.                 int y;
   
6.                 void function() {
   
7.                         y= 7;
   
8.                         System.out.println("inner : " + x);// x 输出7 ;this.x输出4; Outer.this.x
   
9.                 }
   
10.                 class Inner2// 嵌套的嵌套
    
11.                 {
    
12.                         void function2() {
    
13.                                 System.out.println("inner2 : " + y);//输出7
    
14.                         }
    
15.                 }
    
16.                 void method2() {
    
17.                         Inner2 x = new Inner2();
    
18.                         x.function2();
    
19.                 }
    
20.         }
    
21.         void method() {
    
22.                 Inner in = new Inner();
    
23.                 in.function();
    
24.                 in.method2();
    
25.         }
    
26. }

复制代码

因为方法里的x是局部变量，function()和Inner2同在成员位置上，要想Inner2能访问到function()的局部变量，那么就要在方法外部声明一个全局变量作为引用，记住：平级方法里的变量相互是不可见的