大括号{}还能有这些用，静态非静态的代码块以及实例初始化的优先顺序

非静态代码块与静态代码块

非静态代码块

1、非静态代码块的作用

主要用于对实例变量的初始化操作，和构造器类似，所以也可以成为构造代码块。

如果多个重载的构造器有公共代码，而且这些代码都是优先于除了super(【参数】)之外的代码执行的，可以将这些代码抽取出来放到一个代码块中，已达到减少冗余的效果。

2、非静态代码块的执行特点

所有非静态代码块中代码都是在new对象时自动执行，并且一定是先于构造器的代码执行。

3、非静态代码块的语法格式

【修饰符】 class 类{
    {
        非静态代码块
    }
    【修饰符】 构造器名(){
    	// 实例初始化代码
    }
    【修饰符】 构造器名(参数列表){
        // 实例初始化代码
    }
}

静态代码块

为类中的静态成员变量赋初值，可以在创建变量的时直接在其后面赋初始值，也可以使用静态代码块，在静态代码块中为它赋值。

1、语法格式

在代码块的前面加static，就是静态代码块。

【修饰符】 class 类{
	static{
        静态代码块
    }
}

2、静态代码块的特点

每一个类的静态代码块只会执行一次。

静态代码块的执行优先于非静态代码块和构造器。

方法代码

public class Person{

    private static String name;
    private String hobby;

    {
        System.out.println("非静态代码块，name= " + name);
    }

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

    public Person(String hobby) {
        this.hobby= hobby;
    }
}

main方法测试

public class TestStaticBlock {
    public static void main(String[] args) {
        Person person1 = new Person("神农");
        Person person2 = new Person("轩辕");
    }
}

类初始化与实例初始化过程

实例初始化过程

1、实例初始化的目的

实例初始化过程可以说就是new对象为实例变量赋有效初始值的过程。

2、实例初始化相关代码

在new对象的过程中给实例变量赋有效初始值可以通过以下3部分完成：

1. 实例变量直接初始化

2. 非静态代码块中赋值

3. 构造器中赋值

如果没有编写上面3个部分的任何代码，那么实例变量也有默认值。

3、实例初始化执行特点

• 创建对象时，每new一个对象，就会实现对该对象的实例初始化
• 调用哪个构造器，就是执行对应的< init >实例初始化方法
• 子类super()还是super(实参列表)实例初始化方法中的super()或super(实参列表) 不仅仅代表父类的构造器代码了，而是代表父类构造器对应的实例初始化方法。

4、实例初始化方法

我们编写的代码在编译时，会自动处理代码，整理出一个或多个的init(…)实例初始化方法。一个类有几个实例初始化方法，由这个类就有几个构造器决定。

实例初始化方法的方法体，由4部分构成：

（1）super(【参数列表】）

• 这里选择哪个，看子类构造器首行是super()还是super(实参列表)
• 如果原来构造器首行是this()或this(实参列表)，那么就取对应构造器首行的super()或super(实参列表)
• 如果原来构造器首行既没写this()或this(实参列表)，也没写super()或super(实参列表) ，默认就是super()

（2）实例变量的显示赋值语句

（3）非静态代码块

（4）对应构造器中剩下的的代码

其中（2）和（3）是按顺序初始化，（1）一定在最前面（4）一定在最后面

5、演示父类实例初始化

public class Father {
    {
        System.out.println("Father类的非静态代码块1，a = " + a);
        System.out.println("Father类的非静态代码块1，b = " + this.b);
    }
    private int a = 1;
    public Father(){
        System.out.println("Father类的无参构造");
    }
    public Father(int a, int b){
        System.out.println("Father类的有参构造");
        this.a = a;
        this.b = b;
    }
    private int b = 1;
    {
        System.out.println("Father类的非静态代码块2，a = " + a);
        System.out.println("Father类的非静态代码块2，b = " + b);
    }

    public String toString(){
        return "a = " + a + "，b = " + b;
    }
}

public class TestFather {
    public static void main(String[] args) {
        Father father = new Father();
        System.out.println(father);
        System.out.println("-----------------------");
        Father father2 = new Father(99,66);
        System.out.println(father2);
    }
}

6、演示子类实例初始化

public class Son extends Father {
    private int c = 1;
    {
        System.out.println("Son类的非静态代码块,c = " + c);
    }
    public Son() {
        System.out.println("Son类的无参构造");
    }

    public Son(int a, int b, int c) {
        super(a, b);
        this.c = c;
        System.out.println("Son类的有参构造");
    }

    @Override
    public String toString() {
        return super.toString() + ",c = " + c;
    }
}

public class TestSon {
    public static void main(String[] args) {
        Son s = new Son();
        System.out.println(s);
        System.out.println("---------------");
        Son s2 = new Son(10,10,10);
        System.out.println(s2);
    }
}

类初始化

（1）类的初始化就是为静态变量初始化值。实际上，类初始化的过程时在调用一个< clinit >()方法，而这个方法是编译器自动生成的。编译器会将如下两部分的所有代码，按顺序合并到类初始化<clinit>()方法体中。

• 静态类成员变量的显式赋值语句

• 静态代码块中的语句

  当然没有这两部分代码，静态变量也有默认初始值

（2）每个类初始化只会进行一次，如果子类初始化时，发现父类没有初始化，那么会先初始化父类。

（3）类的初始化一定优先于实例初始化。

1、类初始化代码只执行一次

public class Fu{
    static{
        System.out.println("Fu静态代码块1，a = " + Fu.a);//1
    }
    private static int a = 1; //2
    static{
        System.out.println("Fu静态代码块2，a = " + a);//3
    }
    
    public static void method(){
        System.out.println("Fu.method");//4
    }

}

public class TestClassInit {
    public static void main(String[] args) {
        Fu.method();
    }
}

执行顺序：1->2->3->4

2、父类优先于子类初始化

public class Zi extends Fu{
    static{
        System.out.println("Zi静态代码块");//5
    }
}

public class TestZiInit {
    public static void main(String[] args) {
        Zi z = new Zi();
    }
}

执行顺序：1->2->3->5

3、类初始化优先于实例初始化

public class Fu{
    static{
        System.out.println("Fu静态代码块1，a = " + Fu.a);//1
    }
    private static int a = 1;//2
    static{
        System.out.println("Fu静态代码块2，a = " + a);//3
    }

    {
        System.out.println("Fu非静态代码块");//4
    }
    public Fu(){
        System.out.println("Fu构造器");//5
    }

    public static void method(){
        System.out.println("Fu.method");//6
    }
}

public class Zi extends Fu{
    static{
        System.out.println("Zi静态代码块");//7
    }
    {
        System.out.println("Zi非静态代码块");//8
    }
    public Zi(){
        System.out.println("Zi构造器");//9
    }
}

public class TestZiInit {
    public static void main(String[] args) {
        Zi z1 = new Zi();
        Zi z2 = new Zi();
    }
}

初始化顺序：
z1:1->2->3->7->4->5->8->9
z2:4->5->8->9