黑马程序员——————> 使用内部类

定义类的主要作用就是定义变量，创建实例和作为父类被继承。定义内部类的主要作用也是如此，但使用内部类定义变量和创建实例则与外部类存在一些小小的差异。下面分三种情况讨论内部类的用法。

1：在外部类内部类使用内部类

在外部类内部使用内部类时，与平常使用普通类没太大区别。一样可以直接通过内部类类名来定义变量，通过new调用内部类构造器来创建实例。

唯一存在的区别是：不要在外部类的静态成员（包括静态方法和静态初始化块）中使用非静态内部类，因为静态成员不能访问非静态成员。

在外部类内部定义内部类的子类与平常定义子类也没有太大区别。

 

2：在外部类以外使用非静态内部类

如果希望在外部类以外的地方访问内部类（包括静态和非静态两种），则内部类不能使用private访问控制权限，privat修饰的内部类只能在外部类内部使用，对于其他访问控制符修饰的内部类，则能在访问控制符对应凡人访问权限内使用。

（1）省略访问控制符的内部类，只能被与外部类处于同一个包中的其他类所访问。

（2）使用protrcted修饰的内部类，可被与外部类处于同一个包中凡人其他类和外部类的子类所访问。

（3）使用public修饰的内部类，可以在任何地方被访问。

在外部类以外的地方定义内部类（包括静态和非静态两种）变量的语法格式如下：

OuterClass.InnerClass varName

可以看出，在外部类以外的地方使用内部类时，内部类完整的类名应该是OuterClass.InnerClass 如果外部类有包名，则还应该增加包名前缀。

 

由于非静态内部类的对象必须寄生在外部类的对象里，因此创建非静态内部类对象之前，必须先创建其外部类对象。在外部类以外的地方创建非静态内部类实例的语法如下：

OuterInstance.new InnerConstructor()

可以看出，在外部类以外的地方创建非静态内部类的实例必须使用外部类实例和new来调用非静态内部类的构造器。下面程序示范了如何在外部类以外的地方创建非静态内部类的对象，并把它赋给非静态内部类类型的变量。

class Out 
{
    //定义一个内部类，不使用访问控制符
    //即只有同一个包中的其他类可以访问该内部类
    class In
    {
        public In(String msg)
        {
            System.out.println(msg);
        }
    }
}

public class CreateInnerInstance 
{
    public static void main(String[] args) 
    {
        Out.In in = new Out().new In("测试信息");
        
        /**
         *     上面的代码可以改为如下三行代码
         *    使用OuterClass.InnerClass 的形式定义内部类变量
         *    Out.In in;
         *    创建外部类实例，非静态内部类实例将寄生在该实例中
         *    Out out = new Out();
         *    通过外部类实例和new来调用内部类构造器创建非静态内部类实例
         *    in = out.new In("测试信息");
         */
    }
}

上面程序中创建了一个非静态内部类的对象。可以看出，非静态内部类的构造器必须使用外部类对象来调用。
如果需要在外部类以外的地方创建非静态内部类的子类，则尤其要注意上面的规则：非静态内部类的构造器必须通过其外部类对象来调用。当创建一个子类时，子类构造器总会调用父类的构造器，因此在创建非静态内部类的子类时，必须保证让子类构造器可以调用非静态内部类的构造，调用非静态内部类的构造器时，必须存在一个外部类对象。下面程序定义了一个子类继承了Out类的非静态内部类In类。

class SubClass extends Out.In
{

    public SubClass(Out out) 
    {    
        //通过传入的Out对象显式调用In的构造器
        out.super("hello");
    }
    
}

非静态内部类In类的构造器必须使用外部类对象来调用，代码中的super代表调用In类的构造器，而out则代表外部类对象。

如果要创建SubClass对象时，必须先创建一个Out对象。这是合理的，因为SubClass是非静态内部类In类的子类，非静态内部类In对象里必须有一个对Out对象的引用，其子类SubClass对象里也应该持有对Out对象的引用。当创建SubClass对象时传给该构造器的Out对象，就是SubClass对象里Out对象引用所指向的对象。

非静态内部类In对象和SubClass对象都必须持有指向Out对象的引用，区别是创建两种对象时传入Out对象的方式不同：当创建非静态内部类In对象时，必须通过Out对象来调用new关键字；当创建SubClass类的对象时，必须使用Out对象作为调用者来调用In构造器。

 

非静态内部类的子类不一定是内部类，它可以是一个外部类。但非静态内部类的子类实例一样需要保留一个引用，该引用指向其父类所在外部类的对象。也就是说，如果有一个内部类子类的对象存在，则一定存在与之对应的外部类对象。

 

在外部类以外使用静态内部类

因为静态内部类是外部类类相关的，因此创建静态内部类对象时无须创建外部类对象。在外部类以外的地方创建静态内部类实例的语法如下：

 

new OuterClass.InnerConstructor()

 

下面程序示范了如何在外部类以外的地方创建静态内部类的实例。

class StaticOut 
{
    //定义一个静态内部类，不使用访问控制符
    //即同一个包中的其他类可访问该内部类
    static class StaticIn
    {
        public StaticIn()
        {
            System.out.println("静态内部类的构造器");
        }
    }
}

public class CreateStaticInnerInstance 
{

    public static void main(String[] args) 
    {
        StaticOut.StaticIn in = new StaticOut.StaticIn();
        
        /**
         *     上面的代码可该为如下两行代码
         *    使用OuterClass.InnerClass的形式定义内部类变量
         *    StaticOut.StaticIn in;
         *    通过new来调用内部类构造器创建静态内部类实例
         *    in = new StaticOut.StaticIn();
         */
    }

}

可以看出，不管是静态内部类还是非静态内部类，它们声明变量的语法完全一样。区别知识在创建内部类对象时，静态内部类只需要使用外部类即可调用构造器，而非静态内部类必须使用外部类对象来调用构造器。

因为调用静态内部类的构造器时无须使用外部类对象，所以创建静态内部类的子类也比较简单。

class StaticSubClass extends StaticOut.StaticIn{}

当定义一个静态内部类时，其外部类非常像一个包空间。

相比之下，使用静态内部类比使用非静态内部类要简单很多，只要把外部类当成静态内部类的包空间即可。因此当需要使用内部类时，应该优先考虑静态内部类。