第15讲 静态代码块、局部代码块和构造代码块

静态代码块（重要）

作用：数据初始化，且只执行一次

格式：static{ ... }

执行时机：随着类的加载而加载，并且自动触发、只执行一次

使用场景：在类加载的同时，对某些数据初始化。

为什么选择静态代码块初始化？
main函数可以被手动调用，如果在main函数内初始化变量，调用main函数时会导致反复初始化，影响效率。

import java.util.ArrayList;
import java.util.Scanner;

public class Demo {
    //静态只能访问静态，所以集合要用静态修饰
    static ArrayList<Administrators> list = new ArrayList<>();

    //静态代码块：数据初始化，且只执行一次
    static {
        list.add(new Administrators("zhangsan", "10001"));
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请登录");
        System.out.println("用户名：");
        String name = sc.next();
        System.out.println("工号：");
        String id = sc.next();
        for (int i = 0; i < list.size(); i++) {
            if (list.get(i).getName().equals(name) && list.get(i).getId().equals(id)) {
                System.out.println("登陆成功");
            } else {
                System.out.println("登陆失败");
            }
        }
    }
}

//管理员类
class Administrators {
    private String name;
    private String id;

    public Administrators() {
    }

    public Administrators(String name, String id) {
        this.name = name;
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

局部代码块（已淘汰）

作用：提前结束变量的生命周期，回收内存

public class Demo {
    public static void main(String[] args) {
        {
            int num = 10;
        }	//到这里，num的生命周期已经结束，内存已被回收
        
        System.out.println(num); //报错，
    }
}

构造代码块（不够灵活）

作用：把构造方法中的重复代码写在一起

​ 局限性：如只需要Student()和Student(String name)需要执行该代码块，

​ 而Student(String name, int age)不需要执行的情况，就无法用构造代码块实现。

执行时机：在创建本类对象时，会先执行构造代码块，再执行构造方法

//使用场景：无论使用哪种构造创建对象，我都想让他执行一句话："对象已创建"，这时就可以使用构造代码块
public class Demo {
    public static void main(String[] args) {
        System.out.println("Student()构造");
        Student s1 = new Student();

        System.out.println("Student(String name)构造");
        Student s2 = new Student("小明");

        System.out.println("Student(String name, int age)构造");
        Student s3 = new Student("小明", 28);
        //局限：如只需要Student()和Student(String name)需要执行该代码块，
        //     而Student(String name, int age)不需要执行的情况，就无法用构造代码块实现。
    }
}

class Student {
    private String name;
    private int age;
    
    {
        System.out.println("对象已创建");
    }
    
    public Student() {}
    
    public Student(String name) {
        this.name = name;
    }
    
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
/*运行结果
Student()构造
对象已创建
Student(String name)构造
对象已创建
Student(String name, int age)构造
对象已创建
*/

可以用this关键字调用本类的其他构造解决上述构造代码块的局限

public class Demo {
    public static void main(String[] args) {
        System.out.println("Student()构造");
        Student s1 = new Student();

        System.out.println("Student(String name)构造");
        Student s2 = new Student("小明");

        System.out.println("Student(String name, int age)构造");
        Student s3 = new Student("小明", 28);
    }
}

class Student {
    private String name;
    private int age;
    
    public Student() {
        this(null); //调用Student(String name)构造
    }
    
    public Student(String name) {
        System.out.println("对象已创建");
        this.name = name;
    }
    
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
/*运行结果
Student()构造
对象已创建
Student(String name)构造
对象已创建
Student(String name, int age)构造
*/