Java类初始化顺序

发表于 | 分类于 |

Java类初始化顺序

本文总结Java静态代码块、构造代码块、构造函数以及Java类初始化顺序。

1.构造方法

1
2
3
public Hello(){
	//构造方法
    }

构造方法：
1.对象一建立，就会调用与之相应的构造方法，也就是说，不建立对象，构造方法不会运行。
2.构造方法的作用是给对象进行初始化。
3.一个对象建立，构造方法只运行一次，而一般方法可以被该对象调用多次。

2.构造代码块

1
2
3
{
	//构造代码块    
}

构造代码块：

  1. 构造代码块的作用是给对象进行初始化。
  2. 对象一建立就运行构造代码块了，而且优先于构造方法执行。注意，有对象建立，才会运行构造代码块，类不能调用构造代码块的，而且构造代码块先于构造方法执行。
  3. 构造代码块与构造方法的区别是：构造代码块是给所有对象进行统一初始化，而构造方法是给对应的对象初始化，因为构造方法可以有多个，运行哪个构造方法就会建立相应的对象，但无论建立哪个对象，都会先执行相同的构造代码块。也就是说，构造代码块中定义的是不同对象共性的初始化内容。

3.静态代码块

1
2
3
static {
	//静态代码块    
}

静态代码块：

  1. 它是随着类的加载而执行，只执行一次，并优先于主函数。具体说，静态代码块是由类调用的。类调用时，先执行静态代码块，然后才执行主函数的。
  2. 静态代码块其实就是给类初始化的，而构造代码块是给对象初始化的。
  3. 静态代码块中的变量是局部变量，与普通函数中的局部变量性质没有区别。
  4. 一个类中可以有多个静态代码块

4.Java类初始化顺序

  1. 对于一个类的情况
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Hello {
    public Hello(){//构造方法
        System.out.println("构造方法");    
    }
    {//构造代码块
        System.out.println("构造代码块");    
    }
    static {//静态代码块
        System.out.println("静态代码块");        
    }
    public static void main(String[] args) {
    }
}
运行结果：
静态代码块
  1. 创建对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Hello {
    public Hello(){//构造方法
        System.out.println("构造方法");    
    }
    {//构造代码块
        System.out.println("构造代码块");    
    }
    static {//静态代码块
        System.out.println("静态代码块");        
    }
    public static void main(String[] args) {
        Hello a=new Hello();
        Hello b=new Hello();
    }

}

运行结果：
静态代码块
构造代码块
构造方法
构造代码块
构造方法

对于一个类而言，按照如下顺序执行：

  1. 执行静态代码块
  2. 执行构造代码块
  3. 执行构造函数

5.带变量的类初始化顺序

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
 public class InitialOrderTest {      
    public static String staticField = "静态变量";       
    public String field = "变量";
        
    static {
        System.out.println( staticField );
        System.out.println( "静态初始化块" );
    }
       
    {
        System.out.println( field );
        System.out.println( "初始化块" );
    }
       
    public InitialOrderTest()
    {
        System.out.println( "构造方法" );
    }


    public static void main( String[] args )
    {
        new InitialOrderTest();
    }
}

运行结果：
1. 静态变量
2. 静态初始化块
3. 变量
4. 初始化块
5. 构造方法

6.继承情况下类初始化顺序

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
public class HelloA {
    public HelloA(){
        System.out.println("A的构造函数");    
    }
    {
        System.out.println("A的构造代码块");    
    }
    static {
        System.out.println("A的静态代码块");        
    }
}
public class HelloB extends HelloA{
    public HelloB(){
        System.out.println("B的构造函数");    
    }
    {
        System.out.println("B的构造代码块");    
    }
    static {
        System.out.println("B的静态代码块");        
    }
    public static void main(String[] args) {
        HelloB b = new HelloB();        
    }
}
运行结果：
A的静态代码块
B的静态代码块
A的构造代码块
A的构造函数
B的构造代码块
B的构造函数

当涉及到继承时，按照如下顺序执行：

  1. 执行父类的静态代码块，并初始化父类静态成员变量
  2. 执行子类的静态代码块，并初始化子类静态成员变量
  3. 执行父类的构造代码块，执行父类的构造函数，并初始化父类普通成员变量
  4. 执行子类的构造代码块， 执行子类的构造函数，并初始化子类普通成员变量

参考文献

  1. https://www.cnblogs.com/Qian123/p/5713440.html
  2. http://how2j.cn/k/class-object/class-object-init/297.html#nowhere
0%