内部类的加载时机

内部类是延时加载的，也就是说只会在第一次使用时加载。不使用就不加载，所以可以很好的实现单例模式。

package com.brouth.study.test;
 
public class OuterClass
{
    static{
        System.out.println("OuterClass static load.");
    }
 
    public OuterClass()
    {
        System.out.println("flag");
    }
    public OuterClass(String flag)
    {
        System.out.println("flag:"+flag);
    }
    
    class InnerClass
    {
        //private static String te = "";
        /*static{
            System.out.println("InnerClass static load.");
        }*/ 
        private OuterClass out = new OuterClass("inner");
    }
    static class InnerStaticClass
    {
        private static OuterClass out = new OuterClass("innerStatic");
        static{
            System.out.println("InnerStaticClass static load.");
        } 
        private static void load()
        {
            System.out.println("InnerStaticClass func load().");
        }
    }
    public static  OuterClass getInstatnce()
   {
      return OuterClass.InnerStaticClass.out;
   }
    public static void main(String[] args)
    {
        OuterClass.InnerStaticClass.load();
        OuterClass out = OuterClass.InnerStaticClass.out;
        OuterClass.InnerClass innerClass = out.new InnerClass() ;
        //OuterClass.InnerStaticClass.out.
    }
    
}

输出结果如下：

OuterClass static load.
flag:innerStatic
InnerStaticClass static load.
InnerStaticClass func load().
flag:inner

这个用例可以很清楚的看到内部类（不论是静态内部类还是非静态内部类）都是在第一次使用时才会被加载。

对于非静态内部类是不能出现静态模块（包含静态块，静态属性，静态方法等）

非静态类的使用需要依赖于外部类的对象，详见上述对象innerClass 的初始化。

该示例还实现了单例模式。关注其中的getInstatnce方法。