Java类的加载顺序

我欲只争朝夕

发布于 2023-11-9 11:56

浏览

0收藏

Java构造函数，构造代码块，静态代码块的执行时间

public class Constructor {

   public static void main(String[] args) {
       System.out.println("创建第一个对象：");
       Test test1 = new Test();
       System.out.println("");
       System.out.println("创建第二个对象：");
       Test test2 = new Test(5);
   }
}

class Test {
   // 静态代码块1
   static {
       System.out.println("我是静态代码块1");
   }
   // 构造代码块1：
   {
       System.out.println("我是构造代码块1");
   }

   // 构造函数1
   public Test() {
       System.out.println("我是无参构造函数");
   }

   // 构造函数2
   public Test(int t) {
       System.out.println("我是带参构造函数，" + "参数是" + t);
   }

   // 静态代码块2
   static {
       System.out.println("我是静态代码块2");
   }

   // 构造代码块2：
   {
       System.out.println("我是构造代码块2");
   }
}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.

结果

创建第一个对象：
我是静态代码块1
我是静态代码块2
我是构造代码块1
我是构造代码块2
我是无参构造函数

创建第二个对象：
我是构造代码块1
我是构造代码块2
我是带参构造函数，参数是51.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.

执行时间：静态代码块>构造代码块>构造函数，静态代码块只会在类被载入内存时加载一次，构造代码块和构造函数都是在对象创建的时候执行，有几个对象就会执行几次，所以一般将加载配置文件的过程写在静态代码块中

无继承类的加载顺序

public class Parameter {

   public Parameter(String str) {
       System.out.println(str);
   }
}1.
2.
3.
4.
5.
6.

public class Test1 {

   public static Parameter parameter1 = new Parameter("静态成员变量");

   public Parameter parameter2 = new Parameter("非静态成员变量");

   public Test1() {
       System.out.println("构造函数");
   }

   static {
       System.out.println("静态代码块");
   }

   {
       System.out.println("构造代码块a");
   }

   {
       System.out.println("构造代码块b");
   }

   public static void main(String[] args) {
       /*
         静态成员变量
         静态代码块
         非静态成员变量
         构造代码块a
         构造代码块b
         构造函数
       */
       new Test1();
       System.out.println();
       /*
         非静态成员变量
         构造代码块a
         构造代码块b
         构造函数
       */
       new Test1();
   }

}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.

可以看到静态成员变量和静态代码块一样，只会在类被载入内存时加载一次

public class Test2 {

   static {
       System.out.println("静态代码块");
   }

   public Test2() {
       System.out.println("构造函数");
   }

   {
       System.out.println("构造代码块b");
   }

   {
       System.out.println("构造代码块a");
   }

   public static Parameter parameter1 = new Parameter("静态成员变量");

   public Parameter parameter2 = new Parameter("非静态成员变量");

   public static void main(String[] args) {
       /*
         静态代码块
         静态成员变量
         构造代码块b
         构造代码块a
         非静态成员变量
         构造函数
       */
       new Test2();
   }

}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.

执行顺序（静态成员函数在调用时被加载）

1.静态代码块和静态成员变量，加载顺序由编写顺序决定

2.构造代码块和非静态成员变量，加载顺序由编写顺序决定

3.构造函数

有继承类的加载顺序

public class Father {

   public static Parameter parameter1 = new Parameter("父类静态成员变量");

   public Parameter parameter2 = new Parameter("父类非静态成员变量");

   public Father() {
       System.out.println("父类的构造函数");
   }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

public class Son extends Father{

   public static Parameter parameter1 = new Parameter("子类静态成员变量");

   public Parameter parameter2 = new Parameter("子类非静态成员变量");

   public Son() {
       System.out.println("子类的构造函数");
   }

   public static void main(String[] args) {
       /*
         父类静态成员变量
         子类静态成员变量
         父类非静态成员变量
         父类的构造函数
         子类非静态成员变量
         子类的构造函数
       */
       new Son();
   }
}1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.

执行顺序
1. 父类的静态（静态代码块，静态成员变量），子类的静态（静态代码块，静态成员变量）
2. 父类的非静态（构造代码块，非静态成员变量），父类的构造函数
3. 子类的非静态（构造代码块，非静态成员变量），子类的构造函数

文章转载自公众号：Java识堂

分类

其他

标签

java

已于2023-11-9 11:56:37修改

51CTO

51CTO博客

51CTO学堂

Java类的加载顺序

Java构造函数，构造代码块，静态代码块的执行时间

无继承类的加载顺序

有继承类的加载顺序

目录

订阅鸿蒙技术特刊，精选内容抢先看