类的加载顺序

直接上代码，热乎的：

package test;

/**
有父类的情况
1. 加载父类
    1.1 为静态属性分配存储空间并赋初始值 
    1.2 执行静态初始化块和静态初始化语句（从上至下）
2. 加载子类
    2.1 为静态属性分配存储空间
    2.2 执行静态初始化块和静态初始化语句（从上至下）
3. 加载父类构造器
    3.1 为实例属性分配存数空间并赋初始值 
    3.2 执行实例初始化块和实例初始化语句
    3.3 执行构造器内容
4. 加载子类构造器
    4.1 为实例属性分配存数空间并赋初始值 
    4.2 执行实例初始化块和实例初始化语句
    4.3 执行构造器内容
5  回到main()
内部类的加载过程也一样
*/
public class Test {
	public static void main(String[] args) {
		A a = new B();
		A.C c = new A.C();
		new P("============");
		a.getI();
		new P(a.i + "");
		new P("============");
		B b = (B) a;
		b.getI();
		new P(b.i + "");
	}
}

class A {
	public int i = 1;
	// 5
	private P p1 = new P("A--p1");
	// 1
	static P p3 = new P("A--p3");

	public A() {
		// 8
		new P("A()");
	}

	// 6
	private P p2 = new P("A--p2");
	static {
		// 2
		new P("A--static");
	}
	{
		// 7
		new P("A{...}");
	}

	public static class C {
		// 15
		private P p1 = new P("C--p1");
		// 13
		static P p3 = new P("C--p3");

		public C() {
			// 18
			new P("C()");
		}

		// 16
		private P p2 = new P("C--p2");
		static {
			// 14
			new P("C--static");
		}
		{
			// 17
			new P("C{...}");
		}
	}

	public void getI() {
		new P("Father i:" + i);
	}

	/**
	 * private的final方法
	 */
	private final void checkFinal() {

	}
}

class B extends A {
	public int i = 20;
	// 9
	private P p1 = new P("B --p1");
	// 3
	static P p3 = new P("B -- p3");

	public B() {
		// 12
		new P("B()");
	}

	// 10
	public P p2 = new P("B -- p2");
	static {
		// 4
		new P("B -- static");
	}
	{
		// 11
		new P("B{...}");
	}

	public void getI() {
		new P("Son i:" + i);
	}

	/**
	 * 此时是看不到父类的私有方法所以不会报错。
	 */
	private void checkFinal() {

	}
}

class P {
	public static int i = 1;

	public P(String s) {
		System.out.println((i++) + " " + s);
	}
}

/*
1 A--p3
2 A--static
3 B -- p3
4 B -- static
5 A--p1
6 A--p2
7 A{...}
8 A()
9 B --p1
10 B -- p2
11 B{...}
12 B()
13 C--p3
14 C--static
15 C--p1
16 C--p2
17 C{...}
18 C()
19 ============
20 Son i:20
21 1
22 ============
23 Son i:20
24 20
*/