Java内部类

在一个类内部定义类，这就是嵌套类（nested classes），也叫内部类、内置类。嵌套类可以直接访问嵌套它的类的成员，包括private成员，但是，嵌套类的成员却不能被嵌套它的类直接访问。

 

 

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

 

 

 

 

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

 

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

class Outer

{

int outer_i = 100;

void test()

{

Inner inner = new Inner();

inner.display();

}

class Inner

{

int y = 10;

void display()

{

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

}

}

void showy()

{

System.out.println(y);

}

}

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

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类中的成员变量

  }

}
}

 

总结：

1、什么情况下应该使用内部类？

   当a类需要调用b类的对象，而b类的方法需要调用到a类的某个成员时，这个时候就可以把b类作为a类的内部类。

2、内部类对象调用外部类的成员时是怎么实现的？

   在内部类对象保存了一个对当内部类的对象的某个方法要调用一个变量时，如果这个变量在方法和内部类里都没有声明，这个时候调用会被传递给内部类对象保存的外部类对象的引用，通过这个引用调用变量，调用方法也是这样处理。    

3、静态内部类的使用注意事项？

   静态内部类不能调用外部类的非静态变量，而非静态内部类里不能声明静态变量

4、内部类中的同名变量（包括局部）？

   

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类中的成员变量

  }

}
}

 

下面的程序说明了如何定义和使用一个内部类。名为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

评论

1 楼 hanyu332 2010-11-26  

说的很详细,很好~!