类的初始化

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

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

Java代码

1. public class TestA {   
2.   
3.     static class A {   
4.         static String string1 = "内部类--静态数据";   
5.         String string2 = "内部类--实例数据";   
6.         static {   
7.             System.out.println(string1);   
8.         }   
9.         {   
10.             System.out.println(string2);   
11.         }   
12.   
13.     }   
14.   
15.     static String string3 = "主类--静态数据";   
16.     String string4 = "主类--实例数据";   
17.     static {   
18.         System.out.println(string3);   
19.     }   
20.     {   
21.         System.out.println(string4);   
22.     }   
23.   
24.     public static void main(String[] args) {   
25.         new A();   
26.         System.out.println("---------");   
27.         new TestA();   
28.     }   
29. }  

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();
	}
}

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

Java代码

1. public class TestA {      
2.      
3.     class A {      
4.         String string1 = "内部类--实例数据";      
5.         {      
6.             System.out.println(string1);      
7.         }      
8.               
9.         public A(){      
10.             System.out.println("内部类--构造器");      
11.         }      
12.      
13.     }      
14.           
15.     public TestA(){      
16.         System.out.println("主类--构造器");      
17.     }      
18.      
19.     static String string2 = "主类--静态数据";      
20.     String string3 = "主类--实例数据";      
21.     static {      
22.         System.out.println(string2);      
23.     }      
24.     {      
25.         System.out.println(string3);      
26.     }      
27.      
28.     public static void main(String[] args) {      
29.         new TestA().new  A();      
30.     }      
31. }   

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();   
    }   
} 

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

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


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



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

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

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