继续谈类初始化问题，关于内部类

说明：
昨天看到一篇关于谈类初始化问题的，转载了一下，没有发表成功，现在自己将自己的理解整理了一番，希望探讨一下。

由于前面的一篇文章[url]http://zangweiren.iteye.com/blog/208122[/url]没有谈到内部类，现就这个测试一下。

public class TestA {

	static class A {
		static String string1 = "内部类--静态数据";
		String string2 = "内部类--实例数据";
		static {
			System.out.println(string1);
		}
		{
			System.out.println(string2);
		}

	}

	static String string3 = "主类--静态数据";
	String string4 = "主类--实例数据";
	static {
		System.out.println(string3);
	}
	{
		System.out.println(string4);
	}

	public static void main(String[] args) {
		new A();
		System.out.println("---------");
		new TestA();
	}
}

运行上面的代码，会得到如下的结果：
主类--静态数据
内部类--静态数据
内部类--实例数据
---------
主类--实例数据

public class TestA {   

    class A {   
        String string1 = "内部类--实例数据";   
        {   
            System.out.println(string1);   
        }   

        public A(){   
            System.out.println("内部类--构造器");   
        }   

    }   

    public TestA(){   
        System.out.println("主类--构造器");   
    }   

    static String string2 = "主类--静态数据";   
    String string3 = "主类--实例数据";   
    static {   
        System.out.println(string2);   
    }   
    {   
        System.out.println(string3);   
    }   

    public static void main(String[] args) {   
        new TestA().new  A();   
    }   
} 

运行上面的代码，会得到如下的结果：
主类--静态数据
主类--实例数据
主类--构造器
内部类--实例数据
内部类--构造器

可以得出这样的结论：
平常的基础类（即没有继承关系，内部类），初始化顺序：（静态数据|静态块）-->（实例数据|实例块）-->构造器。


继承的类，初始化顺序：继承类首先初始化，如果再次继承以此类推，最顶层类执行（静态数据|静态块），次顶层类执行（静态数据|静态块），以此类推，直至最底层基类，然后最顶层类执行（实例数据|实例块）-->构造器，次顶层类执行（实例数据|实例块）-->构造器，以此类推，直至最底层基类。


内部类（静态）
首先调用静态内部类，初始化顺序:主类（静态变量|静态块）的初始化，静态内部类的（静态数据|静态块）-->（实例数据|实例块）-->构造器，如果再次调用主类，才会初始化主类（实例数据|实例块）-->构造器。
如果首先调用主类，初始化顺序:主类（静态变量|静态块）-->（实例数据|实例块）-->构造器，如果再次调用内部类，初始化顺序：内部类（静态变量|静态块）-->（实例数据|实例块）-->构造器。两个完全是独立的。

内部类（非静态）
初始化顺序：主类（静态变量|静态块）-->（实例数据|实例块）-->构造器，然后内部类（实例数据|实例块）-->构造器。内部类总是与主类的一个对象相绑定。

如果出现两个或者多个内部类，初始化顺序以此类推。