静态代码块,构造代码块,构造函数,局部代码块的执行顺序

本文参考自: https://www.cnblogs.com/ysocean/p/8194428.html#_label1

1. 静态代码块

1.1 格式

class Demo {
    static {
        System.out.println("静态代码块1");
    }

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

1.2 静态代码块的执行时机

• 静态代码块随着类的加载而加载并自动执行, 即类被加载的时候静态代码块就自动执行了, 因此静态代码块的执行时机最早, 早于类中的所有其他成分.
  由于类只加载一次, 因此静态代码块只执行一次. 多个静态代码块按照书写顺序依次执行.

package cn.king.demo01;
/**
 * 静态代码块的执行时机与执行顺序
 */
class Demo {
    static {
        System.out.println("静态代码块1");
    }

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

    static {
        System.out.println("静态代码块3");
        // 在静态代码块中能调用静态方法
        // -- 调用本类的静态方法
        fun1();
        // -- 调用其他类中的静态方法
        Demo02.fun3();
    }

    public static void fun1() {
        System.out.println("Demo类中的静态方法fun1");
    }

    public void fun2() {
        System.out.println("成员方法fun2");
    }
}


class Demo02{
    public static void fun3() {
        System.out.println("Demo02类中的静态方法fun3");
    }
}

public class Demo01 {
    public static void main(String[] args) {
        Demo demo = new Demo();
        /*
         * 输出:
         * 静态代码块1
         * 静态代码块2
         * 静态代码块3
         * Demo类中的静态方法fun1
         * Demo02类中的静态方法fun3
         */
    }
}

• 注意: 静态的只能访问静态的.

1.3 静态代码块的作用

• 给静态变量赋值.
• 将只需要执行一次的代码放到静态代码块中, 例如驱动加载.
• 有一些代码需要项目启动时就执行, 可以将这些代码放到静态代码块中, 例如项目启动需要加载很多配置文件, 加载配置文件的代码就可以放在静态代码块中.

2. 构造代码块

2.1 格式

// {} 放到成员位置叫构造代码块;  {} 放到局部位置叫做局部代码块(基本没用)
class Demo {
    {
        System.out.println("构造代码块01");
    }

    {
        System.out.println("构造代码块02");
    }

    public Demo() {
    }
}

2.2 构造代码块的执行时机

• 构造代码块在创建对象时被调用，每次创建对象都会调用一次构造代码块，但是优先于构造函数执行。
• 多个构造代码块按照书写顺序依次执行.
• 注意: 构造代码块不是优先于构造函数执行，而是依托于构造函数，也就是说，如果你不实例化对象，构造代码块是不会执行的. 解释如下:

class Demo {
    private String name;
    
    {
        System.out.println("构造代码块01");
    }

    {
        System.out.println("构造代码块02");
    }

    public Demo() {
        System.out.println("无参构造被调用");
    }

    public Demo(String name) {
        System.out.println("有参构造被调用");
        this.name = name;
    }
}

// --------- 上述的代码反编译后如下 ------------

class Demo {
    private String name;
    
    public Demo() {
        System.out.println("构造代码块01");
         System.out.println("构造代码块02");
        System.out.println("无参构造被调用");
    }

    public Demo(String name) {
        System.out.println("构造代码块01");
         System.out.println("构造代码块02");
        System.out.println("有参构造被调用");
        this.name = name;
    }
}

2.3 构造代码块的作用

• 和构造函数类似, 构造代码块也能对对象进行初始化.
• 每次创建对象, 都会执行所有的构造代码块; 每次创建对象, 都会执行一个重载的构造方法;
  利用每次创建对象的时候都会提前调用一次构造代码块特性，我们可以做诸如统计创建对象的次数等功能;

3. 构造方法

• 构造函数的命名必须和类名完全相同。在java中普通函数可以和构造函数同名，但是必须带有返回值；
• 构造函数不能被直接调用，必须通过new运算符在创建对象时才会自动调用 ;
• 构造函数的作用主要是创建对象时对对象进行初始化(给对象的成员变量赋值);

4. 普通代码块

• 在类的成员位置使用"{ }“就定义了一个构造代码块;
  在类的局部位置使用”{ }"就定义了一个局部代码块;
• 同一个方法中的多个局部代码块按照书写顺序依次执行;

class Demo {
    private String name;

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

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

    public void fun1() {
        {
            System.out.println("局部代码块");
        }
    }
}

5. 执行顺序

• 静态代码块>构造代码块>构造函数>局部代码块

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

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

    public Demo() {
        System.out.println("构造函数");
    }

    public void fun1() {
        {
            System.out.println("局部代码块");
        }
    }
}

public class Demo01 {
    public static void main(String[] args) {
        Demo demo01 = new Demo();
        demo01.fun1();
        /*
         * 输出:
         * 静态代码块
         * 构造代码块
         * 构造函数
         * 局部代码块
         */
        
        System.out.println("--------");
        
        Demo demo02 = new Demo();
        demo02.fun1();
        /*
         * 输出:
         * 构造代码块
         * 构造函数
         * 局部代码块
         */
    }
}

// 注意静态代码块只会在第一次创建对象时执行一次. 

6. 父子类执行顺序

• 首先执行父类静态的内容，父类静态的内容执行完毕后，接着去执行子类的静态的内容，当子类的静态内容执行完毕之后，再去看父类有没有构造代码块，如果有就执行父类的构造代码块，父类的构造代码块执行完毕，接着执行父类的构造方法；父类的构造方法执行完毕之后，它接着去看子类有没有构造代码块，如果有就执行子类的构造代码块。子类的构造代码块执行完毕再去执行子类的构造方法。

  总之一句话，静态代码块内容先执行，接着执行父类构造代码块和构造方法，然后执行子类构造代码块和构造方法。

package cn.king.demo01;

class SuperClass {
    static {
        System.out.println("父类静态代码块");
    }

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

    public SuperClass() {
        System.out.println("父类构造方法");
    }
}

class SubClass extends SuperClass {
    static {
        System.out.println("子类静态代码块");
    }

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

    public SubClass() {
        System.out.println("子类构造方法");
    }
}

public class Demo01 {
    public static void main(String[] args) {
        SubClass subClass01 = new SubClass();
        System.out.println("-------");
        SubClass subClass02 = new SubClass();

        /*
         * 输出:
         * 父类静态代码块
         * 子类静态代码块
         * 父类构造代码块
         * 父类构造方法
         * 子类构造代码块
         * 子类构造方法
         * -------
         * 父类构造代码块
         * 父类构造方法
         * 子类构造代码块
         * 子类构造方法
         */
    }
}