Java笔记整理 —— 代码块

代码块

基本介绍

    代码块又称为初始化块，属于类中的成员（即类的一部分），类似于方法，将逻辑语句封装在方法体中，用{}包围起来。

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

基本语法

(static){...

};

1. static关键字和分号(;)可写可不写。

2. 代码块分为两类，使用static修饰的叫做静态代码块，没有static修饰的叫做普通代码块/非静态代码块。

3. 逻辑语句可以为任何逻辑语句（输入、输出、方法调用、循环、判断等）。

好处

1. 相当于另外一种形式的构造器（对构造器的补充机制），可以做初始化的操作。

2. 场景：如果多个构造器中都有重复的语句，可以抽取到代码块中，提高代码的重用性。

public class Person {
    private String name;
    private int age;
    private String job;

    {
        System.out.println("输入信息中...");
        System.out.println("请稍后...");
        System.out.println("信息输入成功");
    }  //代码块
    public Person(String name, int age, String job) {
        System.out.println("调用三个参数的构造器");
        this.name = name;
        this.age = age;
        this.job = job;
    }

    public Person(String name) {
        System.out.println("调用一个参数的构造器");
        this.name = name;
    } //不管用哪个构造器创建对象，都会先调用代码块的内容
}

public class Test {
    public static void main(String[] args) {
        Person a = new Person("shang",10,"teacher");
    }
}

注意事项

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

2. 类什么时候被加载 —— (1) 创建对象实例时(new)   (2) 创建子类对象实例，父类也会被加载  (3) 使用类的静态成员时(静态属性，静态方法)。注意只会执行一次。

public class Person {
    private String name;
    public static int id = 10;   //静态属性
    public static void show(){   //静态方法
        System.out.println("调用静态方法");
    }

    {
        System.out.println("调用普通代码块");
    }

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

    public Person(String name) {
        System.out.println("调用构造器");
        this.name = name;
    }
}

public class Test {
    public static void main(String[] args) {
        Person a = new Person("Jack");
        System.out.println(Person.id);
        Person.show();
    }
}

    发现在创建对象时，静态代码块和普通代码块都调用了，因为静态代码块已经调用过一次了，因此调用静态成员时没有调用静态代码块。

3. 普通的代码块，在创建对象实例时，会被隐式的调用，被创建一次，就会调用一次（可以理解为是构造器的补充）。如果只是使用类的静态成员，普通代码块并不会执行。

public class Test {
    public static void main(String[] args) {
        Person a = new Person("Jack");
        Person b = new Person("Tom");
        Person c = new Person("Smith");
    }
}

4. 创建一个对象时，在一个类中的调用先后顺序：(1) 调用静态代码块和静态属性初始化（注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按照他们定义的顺序调用）  (2) 调用普通代码块和普通属性的初始化（注意：普通代码块和普通属性初始化调用的优先级一样，与静态判断方法相同）  (3) 调用构造方法

public class Person {
    public static int id = getId();  //静态变量初始化

    {
        System.out.println("调用普通代码块");
    }   //普通代码块
 
    public int num = getNum();   //普通变量初始化

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

    public static int getId(){
        System.out.println("调用静态方法");
        return 10;
    }

    public int getNum(){
        System.out.println("调用普通方法");
        return 100;
    }

    public Person() {
        System.out.println("调用构造器!");
    }
}

    首先看静态变量初始化以及静态代码块的位置，发现静态变量初始化在前，因此先加载静态变量初始化，为了更明显的看出先后，因此调用了方法。再分析普通变量初始化和普通代码块，最后是构造器。

public class Test {
    public static void main(String[] args) {
        Person a = new Person();  //因为是初始化一个对象，因此静态代码块和普通代码块都调用
    }
}

5. 构造器的最前面其实 隐含了super()和调用普通代码块，静态相关的代码块，属性初始化，在类加载时就执行完毕了，因此优先于构造器和普通代码块。而构造器执行时先执行super和普通代码块，这与第四点相互印证。

public class Person {
    {
        System.out.println("调用父类的普通代码块");
    }
    public Person() {
        //super() 隐藏语句，Object类没有输出信息
        //调用普通代码块  隐藏语句
        System.out.println("调用父类的构造器");
    }
}

public class Student extends Person{
    {
        System.out.println("调用子类的普通代码块");
    }

    public Student(){
        // super() 隐藏语句
        // 调用普通代码块 隐藏语句
        System.out.println("调用子类的构造器");
    }
}

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

6. 静态代码块只能直接调用静态成员，普通代码块可以调用任意成员。

调用顺序总结

1. 父类的静态代码块和静态属性（优先级相同，按书写顺序执行）

2. 子类的静态代码块和静态属性（优先级相同，按书写顺序执行）

3. 父类的普通代码块和普通属性初始化（优先级相同，按书写顺序执行）

4. 父类的构造方法

5. 子类的普通代码块和普通属性初始化（优先级相同，按书写顺序执行）

6. 子类的构造方法

注：为了更好看到属性初始化的顺序，一般用方法给属性初始化，方法里加输出。

    public static int id = getId();  //静态变量初始化
    public static int getId(){
        System.out.println("调用静态方法");
        return 10;
    }