Aaron学习笔记

打印结果如下：

display: outer_i = 100

在程序中，内部类Inner定义在Outer类的范围之内。因此，在Inner类之内的display()方法可以直接访问Outer类的变量outer_i。其实,在内部类对象保存了一个对外部类对象的引用，当内部类的成员方法中访问某一变量时，如果在该方法和内部类中都没有定义过这个变量，调用就会被传递给内部类中保存的那个外部类对象的引用，通过那个外部类对象的引用去调用这个变量，在内部类中调用外部类的方法也是一样的道理。上面的程序代码在内存中的布局，如图3.21所示:

图3.21

F指点迷津：

内部类使得程序代码更为紧凑，程序更具模块化。建议读者先自己试试如何将上面的Inner类改写成Outer类的外部去实现，如果你试图这样做了，并感觉到有些棘手的话，你就非常容易明白作者下面的结论了：当一个类中的程序代码要用到另外一个类的实例对象，而另外一个类中的程序代码又要访问第一个类中的成员，将另外一个类做成第一个类的内部类，程序代码就要容易编写得多，这样的情况在实际应用中非常之多!

一个内部类可以访问它的外部类的成员，但是反过来就不成立了。内部类的成员只有在内部类的范围之内是可知的，并不能被外部类使用。例如：

 1class Outer
 2{
 3   int outer_i = 100;
 4   void test()
 5   {
 6       Inner inner = new Inner();
 7       inner.display();  
 8   }
 9   class Inner
10   {
11      int y = 10;
12      void display()
13      {
14          System.out.println("display:  
15             outer_i = " + outer_i);
16      } 
17   }
18
19   void showy()
20   {
21       System.out.println(y);
22   }
23}
24

编译上面的程序，会出现如下错误：

G:\outer.java:19: cannot resolve symbol

symbol : variable y 

location: class Outer

System.out.println(y);

                       ^

1 error

这里，y是作为Inner的一个实例变量来声明的，对于该类的外部它就是不可知的，因此不能被showy()使用。

如果用static修饰一个内部类，这个类就相当于是一个外部定义的类，所以static的内部类中可声明static成员，但是，非static的内部类中的成员是不能声明为static的。static的内部类不能再使用外层封装类的非static的成员变量，这个道理不难想像！所以static嵌套类很少使用。

我们把前面程序中的Inner内部类声明为static，来看看会出现什么样的错误：

class Outer
{
    int outer_i = 100;
    void test()
    {
        Inner in = new Inner();
        in.display();
    }
    static class Inner
    {
    void display()
    {
        System.out.println("display: 
                 outer_i = " + outer_i);
        }
    }
}
class InnerClassDemo
{
    public static void main(String[] args)
    { 
     Outer outer = new Outer();
    outer.test();
    }
}

程序运行结果：

E:\TestOuter.java:13: non-static variable outer_i cannot be referenced from a static context

         System.out.println("display: outer_i = " + outer_i);

                                                                ^

1 error

这段信息表明Outer类的非静态成员变量outer_i不能被一个静态内部类的成员调用。

如果函数的局部变量（函数的形参也是局部变量），内部类的成员变量，外部类的成员变量重名，我们应该按下面的程序代码所使用的方式来明确指定我们真正要访问的变量。

public class Outer

{
    private int size;
    public class Inner

    {
        private int size;
        public void doStuff( int size)

        {
           size++; // 引用的是doStuff函数的形参

            this.size++; //引用的是Inner类中的成员变量
            Outer.this.size++; // 引用的Outer类中的成员变量

         }

    }
}

这些同名变量在内存中的分配情况如图3.22所示：

图3.22

3.8.2 内部类如何被外部引用

内部类也可以通过创建对象从外部类之外被调用，只要将内部类声明为public即可，请看下面的程序：

 1class Outer
 2
 3{
 4        private int size=10;
 5
 6        public class Inner
 7
 8        {
 9
10            public void doStuff()
11
12            {
13
14                System.out.println(++size);
15
16            }
17
18        }
19
20}
21
22    public class TestInner
23
24    {
25
26        public static void main( String[] args)
27
28        {
29
30            Outer outer = new Outer();
31
32            Outer.Inner inner = outer.new Inner();
33
34            inner.doStuff();
35
36        }
37
38    }
39

程序中，内部类Inner被声明为public，在外部就可以创建其外部类Outer的实例对象，再通过Outer类的实例对象创建Inner类的实例对象，我们就可以使用Inner类的实例对象来调用内部类Inner中的方法了。

3.8.3 方法中定义的内部类

嵌套类并非只能在类里定义，也可以在几个程序块的范围之内定义内部类。例如，在方法中，或甚至在for循环体内部，都可以定义嵌套类，如下面的程序所示：

 1class Outer
 2{
 3    int outer_i = 100;
 4    void test()
 5    {
 6        for(int i=0; i<5; i++)
 7        {
 8            class Inner
 9            {
10                 void display()
11                 {
12                     System.out.println("display: outer_i = " + outer_i);
13                 }
14            }
15
16            Inner inner = new Inner();
17            inner.display();
18        }
19    }
20}
21
22class InnerClassDemo
23{
24    public static void main(String args[])
25    {
26        Outer outer = new Outer();
27        outer.test();
28    }
29｝
30

该程序的这个版本的输出如下所示。

display: outer_x = 100

display: outer_x = 100

display: outer_x = 100

display: outer_x = 100

display: outer_x = 100

在方法中定义的内部类只能访问方法中的final类型的局部变量，因为用final定义的局部变量相当于是一个常量，它的生命周期超出方法运行的生命周期。如：

class InOut
{
    String str= new String("Between");
    public void amethod(final int iArgs)
    {
        int it315;
        class Bicycle
        {
             public void sayHello()
             {
                 System.out.println(str); 
                 System.out.println(iArgs);

             }//End of bicycle class
         }
     }//End of amethod
}

在内部类中的sayHello方法中，我们可以访问变量iArgs和str，但不能访问it315。