java构造函数的运行时序
发布网友
发布时间：2022-05-06 19:46
共2个回答
热心网友
时间：2023-09-14 00:54
Java代码 收藏代码
1.public class C {
2. public C() {
3. System.out.println("C");
4. }
5.}
6.
7.public class E {
8. public E() {
9. System.out.println("E");
10. }
11.}
12.
13.public class F {
14. public F() {
15. System.out.println("F");
16. }
17.}
18.
19.public class G {
20. public G() {
21. System.out.println("G");
22. }
23.}
24.
25.
26.public class H {
27. public H() {
28. System.out.println("H");
29. }
30.}
1)继承自Object的类的构造函数的执行顺序：
假设有如下的一个类I,I的定义如下：
Java代码 收藏代码
1.public class I {
2. public G g = new G();
3. public static E statice0 = new E();
4. static {
5. statice0 = new E();
6. System.out.println("判断static执行的顺序");
7. }
8. public static E statice1;
9. public static F f1;
10. static {
11. System.out.println("测试在static块中执行的顺序1");
12. statice1 = new E();
13. f1 = new F();
14. }
15. static {
16. System.out.println("测试在static块中执行的顺序2");
17. f1 = new F();
18. statice1 = new E();
19. }
20. public static H h = new H();
21.
22. public E e;
23. {
24. System.out.println("aaa");
25. e = new E();
26. }
27.
28. public I(int i) {
29. statice0 = new E();
30. f1 = new F();
31. e = new E();
32. }
33.
34. public static void main(String[] args) {
35. I i = new I(1);
36. }
37.}
执行结果：
E
E
判断static执行的顺序
测试在static块中执行的顺序1
E
F
测试在static块中执行的顺序2
F
E
H
G
aaa
E
F
H
E
从这个结果来可以知道，从Object派生的类将会按照如下的书序执行：
1、静态变量，如果有静态块的话，则按照静态块中变量new的顺序执行静态变量构造函数。如果没有静态块的话，则按照声明的顺序执行。
2、非静态变量，如果有非静态变量初始化块的话，则按照new的顺序执行构造函数，如果没有初始化块则按照声明的顺序执行。
3、执行构造函数，所有的变量按照new的顺序执行构造函数。
2）如果是从非Object类结成的类
看如下的类：
Java代码 收藏代码
1.public class A {
2. private static E e = new E();
3. private F f = new F();
4.
5. public A() {
6. Syst www.hnne.com em.out.println("A");
7. }
8.}
9.
10.public class B extends A {
11. private static D d = new D();
12. private C c = new C();
13.
14. public B() {
15. System.out.println("B");
16. }
17.
18. public static void main(String[] args) {
19. B b = new B();
20. }
21.}
22.
23.
24.public class C {
25. public static E e = new E();
26. public C() {
27. System.out.println("C");
28. }
29.}
执行B中的main，则会打印出如下的结果：
E
H
G
D
F
A
E
C
B
首先分析各个类的调用情况，在父类A中有一个E的静态变量，和一个F的非静态变量，B类继承自A，B有一个D的静态变量和C的非静态变量，D中又有一个H的静态变量和g的非静态变量。
从执行得到的结果可以得到如下的结论：
1、首先执行父类中的静态变量的构造函数，在执行构造函数之前执行静态变量的类中的静态变量的构造函数。因此在上例中首先输出：E
2、执行本类的静态变量的构造函数，同上，需要执行静态变量的类中的静态变量的构造函数。上例中会在执行了A中的E的静态变量后执行D的静态变量的构造函数，在此之前需要执行D中的静态变量H的构造函数，然后执行D中的非静态变量G的构造函数。打印出：H G D
3、执行父类中的非静态变量的构造函数。打印出：f
4、执行父类的构造函数。打印出： A
5、执行本类的非静态变量的构造函数，打印出：E C
6、执行本类中的构造函数，按照new的顺序执行构造函数。打印出：B
热心网友
时间：2023-09-14 00:54
