JAVA初始化块和静态初始化块

初始化块

初始化块对Java对象进行初始化工作。
一个类里可以有多个初始化块。
按照定义的先后顺序执行。

[修饰符]{
	//初始化块代码
	...
}

初始化块的修饰符只能是 static。
使用 static 修饰的称为 静态初始化块。

初始化块和构造函数执行顺序：

public class Person {
    {
        int a = 6;
        if(a > 4){
            System.out.println("初始化块1： a大于4");
        }
        System.out.println("初始化块1");
    }
    {
        System.out.println("初始化块2");
    }
    public Person(){
        System.out.println("无参构造函数");
    }

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


// 执行结果： 
初始化块1： a大于4
初始化块1
初始化块2
无参构造函数

运行结果可以看出：
当创建Java对象时：

1. 先执行初始化块；
2. 如果定义多个初始化块，则前面的先执行，后面的后执行；
3. 然后执行构造函数。
   虽然可以定义多个初始化块，但是没有意义， 一般合并在一起，代码更加简洁。

初始化块和成员变量

public class Person {
    {
        b = 5;
    }
    int b = 8;
    public static void main(String[]  args){
        System.out.println(new Person().b);
    }
}

// 执行结果
8

初始化块和实例变量的初始化顺序按照代码顺序执行。
将 int b = 8; 放在初始化之前， 执行结果会变成 5；

JAVA创建对象时， 先分配内存， 然后安装初始化顺序指定初始值。

初始化块和构造函数

初始化块是构造函数的补充。
初始化块总在构造函数之前执行。
初始化块是一段固定执行的代码， 不接受任何参数， 因此，如果一段初始化代码对所有对象相同， 且不用接收任何参数，则可以把这段初始化代码放在初始化块中。

实际上初始化块是一个假象， 使用javac 编译Java类后， 初始化块消失， 被"还原"到每个构造器中，且位于构造器所有函数的前面。

静态初始化块

使用 static 修饰符定义的初始化块，称为静态初始化块，也叫类初始化块。
普通初始化块是对 对象 初始化， 类初始化块是对类初始化。
因此静态初始化块总是比普通初始化块先执行。

class Root {
    static {
        System.out.println("Root static init");
    }

    {
        System.out.println("Root obj init");
    }

    public Root() {
        System.out.println("Root constructor func");
    }

}

class Mid extends Root {
    static {
        System.out.println("Mid static init");
    }

    {
        System.out.println("Mid obj init");
    }

    public Mid() {
        System.out.println("Mid constructor func");
    }

    public Mid(String msg){
        this();
        System.out.println("Mid has param constructor: " + msg);
    }

}

class Leaf extends Mid{
    static {
        System.out.println("Leaf static init");
    }

    {
        System.out.println("Leaf obj init");
    }



    public Leaf(){
        super("MESSAGE");
        System.out.println("Leaf constructor func ");
    }
}

public class Test{
     public static void main(String[] args){
        new Leaf();
        new Leaf();
    }
}


// 执行结果
Root static init
Mid static init
Leaf static init
Root obj init
Root constructor func
Mid obj init
Mid constructor func
Mid has param constructor: MESSAGE
Leaf obj init
Leaf constructor func 
Root obj init
Root constructor func
Mid obj init
Mid constructor func
Mid has param constructor: MESSAGE
Leaf obj init
Leaf constructor func 

创建了两个 Leaf 对象。
会先进行类初始化， 然后对象初始化， 类初始化执行一遍。
先执行父类初始化， 然后子类初始化。
对象初始化时， 同样先执行父类的 初始化块， 构造函数， 然后执行子类的。

静态初始化块和静态成员变量，初始化的值与代码顺序相同执行。

地址： https://blog.csdn.net/yonggang7/article/details/85200134