Java中的代码块

一、概念

代码块又叫初始化块，是类的一部分，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。

但代码块又和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是在加载类时，或者创建对象时隐式调用。

二、语法

[修饰符]{

        代码

};

注意：

1. 修饰符是可以不写，但是要写的话，也只能写static。
2. 代码块分为两类，有static的叫做静态代码块，没有static修饰的，叫做普通代码块/非静态代码块也行，随便喊无所谓。
3. {}后面的分号";"可以写，也可以不写，一般是写上。

三、代码块的使用场景

当重载的构造器中有需要重复的代码时，可以使用代码块减少代码冗余。即如果多个构造器中都有重复的语句，可以将其抽取到代码块（也叫初始化块）中，提高代码的重用性。

public class codeBlock {
    public static void main(String[] args) {
        Movie movie1 = new Movie("你好，李焕英");
        Movie movie3 = new Movie("唐探3",100,"大导演");

    }
}

class Movie{
    private String name;
    private double price;
    private String director;

    //三个构造器构成重载
    //（1）下面的三个构造器都具有相同的语句
    //（2）代码看起来冗余
    //（3）这时把相同的代码放到一个代码块中即可
    //（4）此时，不管用哪个构造器创建对象，都会先调用代码块的内容
    //（5）代码块调用的优先顺序高于构造器
    {
        System.out.println("电影屏幕打开......");
        System.out.println("开始播放广告");
        System.out.println("电影即将开始......");
    }

    public Movie(String name) {
        System.out.println("Movie(String name)被调用");
        this.name = name;
    }

    public Movie(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public Movie(String name, double price, String director) {
        System.out.println("Movie(String name, double price, String director)被调用");
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

输出结果是：

• 电影屏幕打开......
• 开始播放广告......
• 电影即将开始......
• Movie(String name)被调用
• 电影屏幕打开......
• 开始播放广告......
• 电影即将开始......
• Movie(String name, double price, String director)被调用

可以看出代码块的优先级要高于构造器，先执行代码块再执行构造器。

四、代码块的细节

1、static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。如果是普通代码块，每创建一个对象，就执行一次。

public class CodeBlockDetail{
    psvm{
        AA aa1 = new AA();
        AA aa2 = new AA();
    }
}
class AA{
    //静态代码块，在类加载的时候执行，并且只会执行一次
    static{
        sout("AA的静态代码块1被执行......")
    }
}

输出结果如下：

AA的静态代码块1被执行......

2、普通的代码块，在创建对象实例时，会被隐式的调用。被创建一次，就会调用一次。如果只是使用类的静态成员时，普通代码块并不会被执行。

public class CodeBlockDetail{
    psvm{
        AA aa1 = new AA();
        AA aa2 = new AA();
    }
}
class AA{
    //静态代码块，在类加载的时候执行，并且只会执行一次。普通代码块每实例化一个对象，就执行一次
    static{
        sout("AA的静态代码块1被执行......")
    }
    {
        sout("AA的普通代码块......")

    }
}

输出结果如下：

AA的静态代码块1被执行......

AA的普通代码块......

AA的普通代码块......

3、说白了就是，静态代码块跟类加载有关，类加载的同时执行静态代码块，且只执行一次。普通代码块跟创建对象实例有关（和类加载无关），且每创建一个对象实例，就加载一次。（普通代码块可以看作是构造器的补充，构造器被调用了，普通代码快就会被调用）。

4、静态代码块里面只能调用静态成员（静态方法和静态属性），普通代码块可以调用任意成员。

五、类什么时候被加载（重要）

1、创建对象实例时(new)，类会被加载：

public class CodeBlockDetail{
    psvm{
        //创建对象实例时会加载类
        AA aa = new AA();
    }
}
class AA{
    //静态代码块
    static{
        sout("AA的静态代码块1被执行......")
    }
}

输出结果如下：

AA的静态代码块1被执行......

2、创建子类对象实例时，父类也会被加载，而且父类先被加载，子类后被加载（先有爷爷后有爹，有了爹才有儿子）：

public class CodeBlockDetail{
    psvm{
        //创建子类对象实例时，父类也会被加载
        AA aa = new AA();
    }
}

class BB{
    //静态代码块
    static{
        sout("BB的静态代码块被执行......")
    }

class AA extends BB{
    //静态代码块
    static{
        sout("AA的静态代码块被执行......")
    }
}

输出结果如下：（因为继承的本质是先加载父类，再加载子类）

BB的静态代码块被执行......

AA的静态代码块被执行......

3、使用类的静态成员时（静态属性、静态方法）：

public class CodeBlockDetail{
    psvm{
        //使用类的静态属性
        sout(Cat.n1);
    }
}

class Cat{
    //静态属性
    public static int n1 = 999;
    //静态代码块
    static{
        sout("Cat的静态代码块被执行......")
    }
}

输出结果如下：

Cat的静态代码块被执行......

999

六、创建一个对象时，在一个类中的调用顺序

1、调用静态代码块和静态属性初始化（静态代码块和静态属性初始化的优先级一样，如果有多个静态代码块和静态属性初始化，则按他们定义的顺序调用）。下图的代码，new一个对象时，输出的结果是A静态代码块01，getN1被调用...

2、调用普通代码块和普通属性初始化（普通代码块和普通属性初始化的优先级一样，如果有多个普通代码块和普通属性初始化，则按他们定义的顺序调用）。

3、调用构造方法。

Tips: 静态代码块和静态属性在类加载时，就执行完毕了，因此优先于构造器和普通代码块。

七、存在继承关系时，创建一个对象时的调用顺序（引出）

构造器的最前面其实隐含了super()和调用普通代码块，AAA的父类是object。

class{
    BBB bbb = new BBB();
}

class AAA{
    {
        sout("AAA的普通代码块");
    }

    public AAA(){
        //(1)super()
        //(2)调用本类的普通代码块
        sout("AAA()构造器被调用");
    }
}

class BBB extends AAA{
    {
        sout("BBB的普通代码块");
    }

    public BBB(){
        //(1)super()
        //(2)调用本类的普通代码块
        sout("BBB()构造器被调用");
    }
}

输出结果如下：

AAA的普通代码块

AAA()构造器被调用

BBB的普通代码块

BBB()构造器被调用

八、创建一个子类对象时，他们的静态代码块、静态属性初始化、普通代码块、普通属性初始化、构造方法的调用顺序

1. 父类的静态代码块和静态属性初始化（优先级一样，按定义顺序执行）
2. 子类的静态代码块和静态属性初始化（优先级一样，按定义顺序执行）
3. 父类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）
4. 父类的构造方法
5. 子类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）
6. 子类的构造方法