java中方法的执行顺序

• 先加载父类的静态代码块和静态变量（谁在前先加载谁）
• 然后加载子类的静态代码块和静态变量（谁在前先加载谁）
• 其次加载父类的普通方法赋值的变量和构造代码块（谁在前先加载谁）
• 然后加载父类的构造方法
• 在然后加载子类的普通方法赋值的变量和构造代码块（谁在前先加载谁）
• 最后加载子类的构造方法
• 构造代码块和构造函数的区别在下边

public class functionTest {
    public static void main(String[] args){
        System.out.println("运行functionTest中的main函数，创建D类实例");
        new D();
    }
}

class E{
	E(){
		System.out.println("执行E的构造函数");
	}
	
	public void funcOfE(){
		System.out.println("执行E的函数");
	}
}

class F{
	F(){
		System.out.println("执行F的构造函数");
	}
	
	public void funcOfF(){
		System.out.println("执行F的函数");
	}
}

class B{
	E e=new E();
	static F f=new F();  //父类的静态变量
	public String sb=getSb();
	static{
		System.out.println("执行B类的static块(B包含E类的成员变量,包含静态F类成员变量)");
		f.funcOfF();
	}
	{
		System.out.println("执行B实例的普通初始化块");
	}

	B(){
		System.out.println("执行B类的构造函数(B包含E类的成员变量,包含静态F类成员变量)");
		e.funcOfE();
	}

	public String getSb(){
		System.out.println("初始化B的实例成员变量sb");
		return "sb";
	}
}

class C extends B{
	static{
		System.out.println("执行C的static块(C继承B)");
	}
	{
		System.out.println("执行C的普通初始化块");
	}
	
	C(){
		System.out.println("执行C的构造函数(C继承B)");
	}
}

class D extends C{
	public String sd1=getSd1();
	public static String sd=getSd();
	static{
		System.out.println("执行D的static块(D继承C)");
	}
	{
		System.out.println("执行D实例的普通初始化块");
	}

	D(){
		System.out.println("执行D的构造函数(D继承C);父类B的实例成员变量sb的值为："+sb+";本类D的static成员变量sd的值为："+sd+";本类D的实例成员变量sd1的值是："+sd1);
	}

	static public String getSd(){
		System.out.println("初始化D的static成员变量sd");
		return "sd";
	}

	public String getSd1(){
		System.out.println("初始化D的实例成员变量sd1");
		return "sd1";
	}
}


结果:
运行functionTest中的main函数，创建D类实例
执行F的构造函数
执行B类的static块(B包含E类的成员变量,包含静态F类成员变量)
执行F的函数
执行C的static块(C继承B)
初始化D的static成员变量sd
执行D的static块(D继承C)
执行E的构造函数
初始化B的实例成员变量sb
执行B实例的普通初始化块
执行B类的构造函数(B包含E类的成员变量,包含静态F类成员变量)
执行E的函数
执行C的普通初始化块
执行C的构造函数(C继承B)
初始化D的实例成员变量sd1
执行D实例的普通初始化块
执行D的构造函数(D继承C);父类B的实例成员变量sb的值为：sb;本类D的static成员变量sd的值为：sd;本类D的实例成员变量sd1的值是：sd1


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

• 构造代码块：构造代码块没有名称，它位于类中，使用一对花括号 {} 包裹起来，并且没有参数列表。构造代码块不接受任何参数。

• 构造函数：构造函数有名称，与类名相同，可以有参数列表，用于接受初始化参数。构造函数的参数列表和方法参数一样，可以有零个或多个参数。

• 构造代码块：在创建对象时自动执行，不需要显式调用。

• 构造函数：需要显式调用以创建对象。构造函数的调用通常由 new 关键字触发。

class MyClass {
    {
        // 这是构造代码块，在创建对象时执行
        System.out.println("构造代码块被执行");
    }

    MyClass() {
        // 这是构造函数，在创建对象时执行
        System.out.println("构造函数被执行");
    }
}

public class Main {
    public static void main(String[] args) {
        MyClass obj1 = new MyClass();  // 创建对象，构造代码块和构造函数都被执行
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18