Java笔记 —— 局部代码块，构造代码块，静态代码块

这篇博客是把之前上课时的笔记整理一下，加上我个人的理解和注释，还有一些例子发出来

首先在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，
可以分为局部代码块，构造代码块，静态代码块

局部代码块

局部代码块：
与局部变量的位置相同，在方法的里面出现；
作用：限定变量的生命周期，及早释放，提高内存利用率
在同一个类出现的时候，多个局部代码块的执行顺序是自上而下的。

public class Demo1 {
    public static void main(String[] args) {
        //局部代码块
        {
            int x = 10;
            System.out.println(x);
        }
        {
            String y = "hello";
            System.out.println(y);
        }
    }
}

结果为
10
hello

那么现在，如果在局部代码块的外面访问x和y变量会怎么样

public class Demo1 {
    public static void main(String[] args) {
        //局部代码块
        {
            int x = 10;
            System.out.println(x);
        }
        System.out.println(x);
        {
            String y = "hello";
            System.out.println(y);
        }
        System.out.println(y);
    }
}

结果为

局部代码块里面的变量无法在代码块的外面进行访问

构造代码块

构造代码块：
与成员变量的位置相同，类的里面方法的外面；
作用是将多个构造方法中相同的代码存放到一起，都放入构造代码块中
每次调用构造都执行，并且在构造方法前执行

    执行顺序：
        局部代码块 ——> 构造代码块 ——> 构造方法

class Test{
//Test类的无参构造器
    Test(){
        System.out.println("Test类的无参构造方法");
    }
//构造代码块
    {
        System.out.println("Test类的构造代码块");
    }
}

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

结果为

在创建Test类的对象时，调用了类面的无参构造器和构造代码块，而且先执行构造代码快，后执行无参构造器
再来看看多个构造器的情况

class Test{
    public int t1;
    //Test类的无参构造方法
    Test(){
        System.out.println("Test类的无参构造方法");
    }
    //Test类的带一个参数的构造方法
    Test(int i){
        this.t1 = i;
        System.out.println("Test类的带一个参数的构造方法");
    }
	//构造代码块
    {
        System.out.println("Test类的构造代码块");
    }
}

public class Demo1 {
    public static void main(String[] args) {
        Test c1 = new Test();
        Test c2 = new Test(2);
    }
}

结果为

可以看出来创建对象时，都需要执行一次构造代码块，然后是执行构造器。所以可以将不同构造器中相同的内容都放入构造代码块中。

最后再来看局部代码块，构造代码块，构造方法的执行顺序

class Test{
    public int t1;
//    static {
//        System.out.println("这是静态代码块1");
//    }

    Test(){
        System.out.println("Test类的无参构造方法");
    }

    Test(int i){
        this.t1 = i;
        System.out.println("Test类的带一个参数的构造方法");
    }

    {
        System.out.println("Test类的构造代码块");
    }

//    static {
//        System.out.println("这是静态代码块2");
//    }
}

public class Demo1 {
    public static void main(String[] args) {
        {
            int x = 111;
            System.out.println(x);
        }
        {
            String y = "hello";
            System.out.println(y);
        }
        Test c1 = new Test();
        Test c2 = new Test(2);
    }
}

结果为

执行顺序是局部代码块 —> 构造代码块 —> 构造方法

静态代码块

静态代码块：
在类里面的方法的外面出现，并加上static修饰；
用于给类进行初始化，在加载的时候就执行，并且只执行一次。

局部代码块 ——> 静态代码块 ——> 构造代码块 ——> 构造方法

多个静态代码块在一个类中， 他们之间的执行顺序是自上而下的。

class Test{
    public int t1;
    static {
        System.out.println("这是一个静态代码块");
    }

    Test(){
        System.out.println("Test类的无参构造方法");
    }

    Test(int i){
        this.t1 = i;
        System.out.println("Test类的带一个参数的构造方法");
    }

    {
        System.out.println("Test类的构造代码块");
    }
}

public class Demo1 {
    public static void main(String[] args) {
        Test c1 = new Test();
        Test c2 = new Test(2);
    }
}

结果为

静态代码块不是伴随着对象的创建而执行的，而是伴随着类的初始化，执行且只执行一次
main方法中第一次创建对象的时候，会初始化一次类，静态代码块会在加载时执行
因此虽然创建了两个Test类的对象，但是只打印了一次静态代码块

现在来看一下代码块之间的执行顺序问题

class Test{
    public int t1;
    static {
        System.out.println("这是第一个静态代码块");
    }

    Test(){
        System.out.println("Test类的无参构造方法");
    }

    Test(int i){
        this.t1 = i;
        System.out.println("Test类的带一个参数的构造方法");
    }

    {
        System.out.println("Test类的构造代码块");
    }

    static {
        System.out.println("这是第二个静态代码块");
    }
}

public class Demo1 {
    public static void main(String[] args) {
        {
            int x = 111;
            System.out.println(x);
        }
        {
            String y = "hello";
            System.out.println(y);
        }
        Test c1 = new Test();
        Test c2 = new Test(2);
    }
}

结果为

为了方便观察，打印了一些用于分隔的符号
从结果可以看出来，
先执行局部代码块，局部代码块之间按从上到下的顺序执行。
再执行静态代码块，静态代码块之间按从上到下的顺序执行。
再执行构造代码块，第一个对象的构造代码块与无参构造方法先后执行
最后执行第二个对象的构造代码块和带一个参数的构造方法

简短的来说就是
局部代码块 —> 静态代码块 —> 构造代码块 —> 构造方法
（这里有个前提，局部代码块在创建对象语句之前时，才会先执行局部代码块。如果在创建对象语句之后，那么就是等构造方法执行完毕后才运行局部代码块）

涉及到父类和子类时，代码块的执行顺序

package review;

class School{
    private String name;
    static{
        System.out.println("父类静态代码块");
    }
    {
        System.out.println("父类构造代码块1");
    }
    public School(){
        System.out.println("父类无参构造方法");
    }
    {
        System.out.println("父类构造代码块2");
    }
    public School(String name){
        System.out.println("父类含参构造方法");
    }
}

class Clazz extends School{
    static{
        System.out.println("子类的静态代码块");
    }
    {
        System.out.println("子类构造代码块1");
    }
    public Clazz(){
        System.out.println("子类无参构造方法");
    }
    {
        System.out.println("子类构造代码块2");
    }
    public Clazz(String name){
        super(name);
        System.out.println("子类含参构造方法");
    }
}
public class codeTest1 {
    public static void main(String[] args) {
    	{
            System.out.println("局部代码块 before");
        }
        Clazz c = new Clazz();
        System.out.println("-------------");
        Clazz c1 =  new Clazz("一班");
        System.out.println("-------------");
        School s = new School();
        
        {
            System.out.println("局部代码块 after");
        }
    }
}

当局部代码块在创建对象之前时，先执行局部代码块。当局部代码块在main方法的最后一行时，就最后执行。
Java笔记 —— 创建对象的过程（类加载，具体的初始化赋值过程）

Clazz c = new Clazz();创建对象语句会触发静态代码块，构造代码块，构造方法。然后局部代码块优先级相当于普通语句，按从上到下的顺序执行。

这里总结一下上面的结果图中，创建子类对象时的执行顺序：

1. 局部代码块
2. 全部的父类静态代码块，彼此间顺序从上到下执行
3. 全部的子类静态代码块，彼此间顺序从上到下执行
4. 全部的父类构造代码块，彼此间顺序从上到下执行
5. 父类构造方法
6. 全部的子类构造代码块，彼此间顺序从上到下执行
7. 子类构造方法
8. 局部代码块