java构造函数的运行时序

Posted 2023-05-16

首先假设有如下的一些辅助类，这些类被其他类使用作为静态变量或非静态变量：

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.hnnedu.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 参考技术A 应该先运行父类的构造函数 在运行自己的

java-面向对象-构造代码块

class Person

{

　　private string name;

　　private int age;

　　/*

　　构造代码块

　　作用：给对象进行初始化

　　对象一建立就运行，而且优先于构造函数执行

　　和构造函数的区别：

　　构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象进行初始化

　　构造代码块定义不同对像的共性

　　*/

　　{

　　　　System.out.println("person code run");

　　}

　　Person()

　　{

　　　　System.out.println("person");

　　}

}

 

class Persondemo()

{

　　Person p1= new Person();

}