直接上代码,热乎的:
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
*/