JAVA类的初始化顺序(静态变量,静态模块,变量,模块,构造器)

package com.luke.java;

/**
 *@descripton 
 *@author               luke
 *@time                 2012-7-20:下午02:13:27
 *@version                       
 */
public class ClassA
{

	/**
	 * <p>Title: </p>
	 * <p>Description: </p>
	 */
	
	public ClassA(String msg)
	{
		super();
		// TODO Auto-generated constructor stub
		System.out.println(msg + " in ClassA");
	}

}

 package com.luke.java;

/**
 *@descripton 
 *@author               luke
 *@time                 2012-7-20:下午02:14:12
 *@version                       
 */
public class ClassB
{
	public ClassB(String msg)
	{
		super();
		// TODO Auto-generated constructor stub
		System.out.println(msg + " in ClassB");
	}

}

 package com.luke.java;

/**
 *@descripton 
 *@author               luke
 *@time                 2012-7-20:下午02:12:57
 *@version                       
 */
public class Parent
{
	private static ClassA classA = new ClassA("parent static classA");
	
	static
	{
		System.out.println("parent static block");
	}
	
	
	private int i = 10;
	
	{
		System.out.println("parent common block");
		
	}
	
	private ClassB classB = new ClassB("parent common classB");
	
	public Parent(int i)
	{
		this.i = i;
		System.out.println("parent constructor");
	}
	
	public void callInnerClass()
	{
		InnerClass innerClass = new InnerClass();
	}
	
	protected static class InnerClass
	{
		private static ClassA classA = new ClassA("parent InnerClass static classA");
		
		static
		{
			System.out.println("parent InnerClass static block");
		}
		
		
		private ClassB classB = new ClassB("parent InnerClass common classB");
		
		{
			System.out.println("parent InnerClass common block");
			
		}
		
		public InnerClass()
		{
			System.out.println("parent InnerClass constructor");
		}
	}

}

 package com.luke.java;

/**
 *@descripton 
 *@author               luke
 *@time                 2012-7-20:下午02:21:19
 *@version                       
 */
public class Child extends Parent
{
	private static ClassB classB = new ClassB("child static classB");

	static
	{
		System.out.println("child static block");
	}

	private ClassA classA = new ClassA("child common classA");
	
	private int j = 20;


	{
		System.out.println("child common block");

	}

	public Child(int i, int j)
	{
		super(i);
		// TODO Auto-generated constructor stub
		this.j = j;
		System.out.println("child constructor");
	}
	
	public void callInnerClass()
	{
		//Parent.InnerClass innerClass = new Parent.InnerClass();//如果Parent的InnerClass设置成private就不能引用
		InnerClass innerClass = new InnerClass();
	}
	
	private static class InnerClass
	{
		private static ClassA classA = new ClassA("child InnerClass static classA");
		
		static
		{
			System.out.println("child InnerClass static block");
		}
		
		
		private ClassB classB = new ClassB("child InnerClass common classB");
		
		{
			System.out.println("child InnerClass common block");
			
		}
		
		public InnerClass()
		{
			System.out.println("child InnerClass constructor");
		}
	}

}

 package com.luke.java;

/**
 *@descripton 
 *@author               luke
 *@time                 2012-7-20:下午02:12:36
 *@version                       
 */
public class LoadOrderTest
{

	/**
	 *@description
	 *@param
	 *@return                void 
	 *@author                luke
	 *@time                  2012-7-20:下午02:12:36
	 *@version
	 */

	public static void main(String[] args)
	{
		// TODO Auto-generated method stub
		/*
		 * 输出结果如下
		 * 
		   parent static classA in ClassA
           parent static block
           parent common block
           parent common classB in ClassB
           parent constructor
           parent InnerClass static classA in ClassA
           parent InnerClass static block
           parent InnerClass common classB in ClassB
           parent InnerClass common block
           parent InnerClass constructor 
		 * */
		Parent parent = new Parent(60);
		parent.callInnerClass();
	
		/*
		 * 输出结果如下
		 * 
		   parent static classA in ClassA
           parent static block
           child static classA in ClassB
           child static block
           parent common block
           parent common classB in ClassB
           parent constructor
           child common classA in ClassA
           child common block
           child constructor
           child InnerClass static classA in ClassA
           child InnerClass static block
           child InnerClass common classB in ClassB
           child InnerClass common block
           child InnerClass constructor

		 * */
		Child child = new Child(30, 40);
		child.callInnerClass();
		

	}

}

 

 

 说明 :

1.静态变量与静态模块是最先初始化的，它是属于进程的静态常量区

2.Parent的构造器要先于它的子类,这一点是肯定的，但Parent的变量,初始化模块要先于它的子类，构造器可能涉及到类变量操作，所以既然先初始化了父类的构造器，那父类的成员变量也当然要先构造

3.静态变量与静态模块的初始化顺序是根据在类里面定义的顺序，同理变量化初始化模块的顺序也是根据类里面定义的顺序

4.内部静态类在用的时候才会初始化

先父类后子类；

先静态，再初始化，最后构造函数；

父类静态变量（静态初始化块）(按类定义顺序)> 子类静态变量（静态初始化块）(按类定义顺序)>父类普通变量（普通初始化块）(按类定义顺序)>父类构造方法>父类普通方法>子类普通变量（普通初始化块）(按类定义顺序)>子类构造方法>子类普通方法