静态代码块和类初始化、实例初始化过程

非静态代码块和实例初始化过程

1. 静态代码块

静态代码块：定义在类中方法外，使用static修饰

①可以为类变量（静态变量）初始化

②静态代码块在第一次使用这个类之前执行，即在类初始化时执行，且只执行一次

③若有多个静态代码块，那么按照定义的先后顺序依次执行

④在静态代码块中不能访问非静态成员（属性、方法、内部类）

⑤在静态代码块中不能使用this和super关键字

⑥静态代码块的执行优先于main方法、非静态代码块和构造方法的执行

⑦父类静态代码块的执行优先于子类静态代码块执行

代码示例：

public class StaticBlockTest {
    public static void main(String[] args) {
        MyClass.show();
        MyClass.show();
        MyClass.show();
    }

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

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

    public static void show() {
        System.out.println("MyClass类静态方法");
    }

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

}

运行结果：

StaticBlockTest类静态代码块
MyClass类静态代码块1
MyClass类静态代码块2
MyClass类静态方法
MyClass类静态方法
MyClass类静态方法

2. 类初始化

类初始化即执行类初始化方法：<clinit>()

类初始化方法，一个类只有一个。它也是由编译器编译生成的，由两部分代码组成：

①静态变量的显式赋值代码

②静态代码块的代码

其中①和②是按定义的先后顺序依次执行的

代码示例：

public class InitTest {
    public static void main(String[] args) {
        MyClass my = new MyClass();     
    }
}

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

    private static String str = assingn();

    public static void show() {
        System.out.println("MyClass类静态方法");
    }

    private static String assingn() {
        System.out.println("assign()方法为静态变量显式赋值");
        return "java";
    }

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

运行结果：

MyClass类静态代码块1
assign()方法为静态变量显式赋值
MyClass类静态代码块2

3. 子类初始化

一个类初始化时会先检查它的父类是否初始化，如果父类没有初始化，那么会先初始化父类

（1）父类的初始化()

• 父类的静态变量的显式赋值

• 父类的静态代码块

（2）子类的初始化()

• 父类的静态变量的显式赋值

• 父类的静态代码块

代码示例：

public class InitTest2 {

    public static void main(String[] args) {
        /*Father f = new Father();
        System.out.println("--------分隔线---------");*/
        Son s = new Son();
    }

}

class Father{
    private static String info = assign();

    static{
        System.out.println("父类的静态代码块");
    }
    //静态方法不能被重写
    public static String assign(){
        System.out.println("父类assign()方法");
        return "Father";
    }
}

class Son extends Father{
    private static String info = assign();

    static{
        System.out.println("子类的静态代码块");
    }
    
    public static String assign(){
        System.out.println("子类assign()方法");
        return "Son";
    }
}

运行结果：

父类assign()方法
父类的静态代码块
子类assign()方法
子类的静态代码块

4. 类初始化和实例初始化结合

先执行类初始化，后执行实例初始化

代码示例：

public class InitTest3 {

    public static void main(String[] args) {
        Demo d = new Demo();
    }

}

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

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

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

    private static String info = assignInfo();

    private String msg = assignMsg();

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

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


    public static String assignInfo(){
        System.out.println("assignInfo()方法");
        return "hello";
    }

    public String assignMsg(){
        System.out.println("assignMsg()方法");
        return "msg";
    }
}

运行结果：

静态代码块1
assignInfo()方法
静态代码块2
非静态代码块1
assignMsg()方法
非静态代码块2
无参构造

5. 子类初始化和子类实例初始化结合

执行顺序：①父类的类初始化 => ②子类的类初始化 => ③父类的实例初始化方法 => ④子类的实例初始化方法

public class InitTest4 {

    public static void main(String[] args) {
        //Father f = new Father();

        Son s = new Son();
    }

}

class Father {
    {
        System.out.println("父类非静态代码块1");
    }

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

    private static String info = assignInfo();

    private String msg = assignMsg();

    public Father() {
        System.out.println("父类无参构造");
    }

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

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


    public static String assignInfo() {
        System.out.println("父类assignInfo()方法");
        return "hello";
    }

    public String assignMsg() {
        System.out.println("父类assignMsg()方法");
        return "msg";
    }
}

class Son extends Father {
    {
        System.out.println("子类非静态代码块1");
    }

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

    private static String info = assignInfo();

    private String msg = assignMsg();

    public Son() {
        System.out.println("子类无参构造");
    }

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

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


    public static String assignInfo() {
        System.out.println("子类assignInfo()方法");
        return "hello";
    }

    public String assignMsg() {
        System.out.println("子类assignMsg()方法");
        return "msg";
    }
}

父类静态代码块1
父类assignInfo()方法
父类静态代码块2
子类静态代码块1
子类assignInfo()方法
子类静态代码块2
父类非静态代码块1
子类assignMsg()方法
父类非静态代码块2
父类无参构造
子类非静态代码块1
子类assignMsg()方法
子类非静态代码块2
子类无参构造