JAVA技术专题综述之内部类篇

核心提示：有些类的定义中包含另一个类的定义，这种处于内部的类称为内部类(inner class)，JAVA技术专题综述之内部类篇， 例如：public class OuterClass { public class InnerClass { //---This is a inner class. } } InnerClass类

　　有些类的定义中包含另一个类的定义。这种处于内部的类称为内部类(inner class)。
　　例如：
　　public class OuterClass
　　{
　　public class InnerClass
　　{
　　//---This is a inner class.
　　}
　　}
　　InnerClass类嵌套在OuterClass中，并且被声明为public，因此被OuterClass类之外的对象访问。
　　InnerClass类没有被声明为OuterClass类的一个静态成员，因此除非生成了一个OuterClass对象，否则无法生成任何InnerClass对象。但是，当你声明一个包含嵌套类的类对象时，并不一定会生成嵌套类的对象，这主要由包含嵌套类的类的构造方法决定。
　　示例1：
　　class OuterClass
　　{
　　class InnerClass
　　{}
　　}
　　public class Test
　　{
　　public static void main(String[] args)
　　{
　　OuterClass out = new OuterClass();
　　OuterClass.InnerClass in = out.new InnerClass();
　　}
　　}
　　我们使用OuterClass out = new OuterClass();语句生成了一个OuterClass类对象。然后又使用OuterClass.InnerClass in = out.new InnerClass();语句借助外部类的实例生成了一个内部类的对象。main()方法中的两条语句也可以用下面的这一条语句替换：
　　OuterClass.InnerClass in = new OuterClass().new InnerClass();
　　总之：在一个类(Test)中，创建另一个类(OuterClass)中的非静态内部类(InnerClass)必须要借助这个外部类(OuterClass)的一个实例。而且这个内部类对象的声明也必须用OuterClass.InnerClass的形式。
　　示例2：
　　public class Test
　　{
　　class InnerClass
　　{}
　　1
　　public static void main(String[] args)
　　{
　　InnerClass in = new Test().new InnerClass();
　　}
　　}
　　在main()方法中实例化本类的内部类可以用上例的形式。
　　示例3：
　　public class Test
　　{
　　class InnerClass
　　{}
　　InnerClass in = new InnerClass();
　　public static void main(String[] args)
　　{}
　　}
　　在main()方法外，实例化本类的内部类就和我们平常的操作一样了。
　　示例4：
　　public class Test
　　{
　　class InnerClass
　　{}
　　public void method()
　　{
　　InnerClass in = new InnerClass();
　　}
　　public static void main(String[] args)
　　{}
　　}
　　在本类的非静态方法中，实例化本类的内部类也和我们平常的操作一样。
　　
　　　　为了让内部类的对象不依靠于外部类的对象，你可以把内部类声明为static。
　　
　　　　示例5：
　　
　　class OuterClass
　　{
　　static class InnerClass
　　{}
　　}
　　public class Test
　　{
　　public static void main(String[] args)
　　{
　　2
　　OuterClass.InnerClass in = new OuterClass.InnerClass();
　　}
　　}
　　
　　　　从这个例子我们可以看出：创建InnerClass类的对象不再需要OuterClass类的对象。但依然要用OuterClass.InnerClass这个形式声明in对象。
　　
　　　　示例6：
　　
　　class Outer
　　{
　　static int outer_stat = 0;
　　int outer_non_stat = 1;
　　static class StaticInner
　　{
　　static int stat = 2;
　　static int stat_test = outer_stat;
　　public void tester()
　　{
　　System.out.PRintln("outer_stat = " + outer_stat);
　　}
　　}
　　class NonStaticInner
　　{
　　public void tester()
　　{
　　System.out.println("outer_stat = " + outer_stat);
　　System.out.println("outer_non_stat = " + outer_non_stat);
　　System.out.println("StaticInner.stat = " + StaticInner.stat);
　　}
　　}
　　}
　　public class Test
　　{
　　public static void main(String[] args)
　　{
　　new Outer().new NonStaticInner().tester();
　　System.out.println("------------");
　　new Outer.StaticInner().tester();
　　}
　　}
　　输出结果：
　　outer_stat = 0
　　outer_non_stat = 1
　　StaticInner.stat = 2
　　3
　　------------
　　outer_stat = 0
　　NonStaticInner类中的System.out.println("outer_stat = " + outer_stat);语句说明：非静态内部类的非静态成员可以访问外部类的静态变量。