【JAVA学习】内部类

本文核心内容：

1）嵌套类可以直接访问嵌套它的类的成员，包括private成员，但是，嵌套类的成员却不能被嵌套它的类直接访问。

2）在类中直接定义的嵌套类的使用范围，仅限于这个的类的内部，也就是说，A类里定义了一个B类，那么B为A所知，却不被A的外面所知。内部类的定义和普通类的定义没什么区别，它可以直接访问和引用它的外部类的所有变量和方法，就像外部类中的其他非static成员的功能一样，和外部类不同的是，内部类可以声明为private或protected。

3）当一个类中的程序代码要用到另外一个类的实例对象，而另外一个类中的程序代码又要访问第一个类中的成员，将另外一个类做成第一个类的内部类，程序代码就要容易编写得多，这样的情况在实际应用中非常之多!

 

全文如下：

下面转自：http://www.cppblog.com/wangfeng2500/articles/123737.html

 

3.8 内部类

        在一个类内部定义类，这就是嵌套类（nested classes），也叫内部类、内置类。读者以后不要死抠这些名称术语，不同的书籍有不同的翻译风格，你只要知道怎么回事就行了。我曾经碰到一个学员为了弄清楚方法与函数的区别（因为有的书叫方法，有的书叫函数，反而把他给弄糊涂了），翻阅了大量的书籍，都没有搞清楚这两者的区别，其实是同一个事务的两种不同叫法，因为他思考方式的问题，反而在他那变得复杂了。嵌套类可以直接访问嵌套它的类的成员，包括private成员，但是，嵌套类的成员却不能被嵌套它的类直接访问。

3.8.1 类中定义的内部类

        在类中直接定义的嵌套类的使用范围，仅限于这个的类的内部，也就是说，A类里定义了一个B类，那么B为A所知，却不被A的外面所知。内部类的定义和普通类的定义没什么区别，它可以直接访问和引用它的外部类的所有变量和方法，就像外部类中的其他非static成员的功能一样，和外部类不同的是，内部类可以声明为private或protected。

下面的程序说明了如何定义和使用一个内部类。名为Outer的类定义了一个实例变量outer_i，一个test()方法，和一个名为Inner的内部类。

class  Outer
{
   int outer_i = 100;
   void test()
   {
       Inner in = new Inner();
       in.display();
   }
   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();
    }
}

打印结果如下：

display: outer_i = 100

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

                                                    

图3.21

F指点迷津：

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

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

 

 1 class  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即可，请看下面的程序：

 

 1 class  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循环体内部，都可以定义嵌套类，如下面的程序所示：

 

 1 class  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
22 class  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。