JAVA中的代码块

一、基本语法

[修饰符]{
    代码;
};

{
    System.out.println(111);
}

1.修饰符可选，要写的话也只能写static
2.代码块分为两类 使用static修饰的是静态代码块 没有static修饰的叫普通代码块
3.逻辑语句可以为任何逻辑语句
4.;可以不写

1)静态代码块 作用是对类进行初始化 并且只会执行一次

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

2)如果是普通代码块每创建一个对象就执行一次 创建实例对象的时，会被隐式调用

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

二、类加载

1.创建对象实例时(new)
2.创建子类对象实例，父类也会被加载 父类先被加载，子类后加载
3.使用类的静态成员时 (静态属性、静态方法)也会执行代码块

三、类什么时候被加载

 1.创建对象实例时(new)

 2.创建子类对象实例，父类也会被加载 父类先被加载，子类后加载

 3.使用类的静态成员时 (静态属性、静态方法)也会执行代码块

小结:
    static代码块是类加载时执行，只会被执行一次
    普通代码是创建对象时被调用的，创建一次调用一次

四、创建对象时，类调用的顺序

1.调用静态代码块和静态初始化
2.调用普通代码块和普通属性的初始化
3.调用构造器方法
注：多个静态/普通代码块等 按定义顺序来执行

public class CodeBlockDetail02 {
    public static void main(String[] args) {
        // 1)静态代码块 2)getN1()方法被调用
        // 3)普通代码块 4)getN2()方法被调用
        // 5)无参构造器
        A a = new A();
    }
}
class A{

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

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

    static {
        System.out.println("静态代码块");
    }
    private static int n1 = getN1();
    private int n2 = getN2();

    public static int getN1() {
        System.out.println("getN1()方法被调用");
        return 100;
    }

    public static int getN2() {
        System.out.println("getN2()方法被调用");
        return 100;
    }
}

五、创建子类时继承关系顺序

• 1.父类的静态代码块和静态属性（定义顺序）

• 2.子类的静态代码块和静态属性（定义顺序）

• 3.父类的普通代码块和普通属性（定义顺序）

• 4.父类的构造器

• 5.子类的普通代码块和普通属性（定义顺序）

• 6.子类的构造器

public class CodeBlockDetail04 {
    /* 静态代码块只能调用静态成员
    * 普通代码块可以调研任意成员*/
    public static void main(String[] args) {
        /* 1.父类的静态代码块
           2.子类的静态代码块
           3.父类的普通代码块
           4.父类的构造器
           5.子类的普通代码块
           6.子类的构造器
        */
        new Child();
    }
}

class Father{
    public Father() {
        System.out.println("父类的构造器");// (7)
    }

    {
        System.out.println("父类的普通代码块");// (5)
    }

    private static int n1 = getVal01();
    private int n2 = getVal02();

    public static int getVal01(){
        System.out.println("父类的静态方法");// (1)
        return 100;
    }

    public int getVal02(){
        System.out.println("父类的普通方法");// (8)
        return 200;
    }

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

class Child extends Father{
    private static int n3 = getVal03();
    private int n4 = getVal04();

    public static int getVal03(){
        System.out.println("子类的静态方法");// (3)
        return 100;
    }

    public int getVal04(){
        System.out.println("子类的普通方法");// (9)
        return 200;
    }
    public Child() {
        System.out.println("子类的构造器");// (10)
    }

    {
        System.out.println("子类的普通代码块");// (6)
    }

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

六、细节

1.构造器的最前面其实隐含了super()和调用普通代码块

静态相关的代码块属性初始，在类加载时就执行完毕了
因此优先于构造器和普通代码执行块

public class CodeBlockDetail03 {
    public static void main(String[] args) {
        /*  1)AAA的普通代码块
            2)AAA()被调用
            3)BBB的普通代码块
            4)BBB()被调用了
        */
        new BBB();
    }
}

class AAA{
    {
        System.out.println("AAA的普通代码块");
    }
    public AAA(){
        // 隐藏了super();
        System.out.println("AAA()被调用");
    }
}

class BBB extends AAA{
    {
        System.out.println("BBB的普通代码块");
    }
    public BBB() {
        System.out.println("BBB()被调用了");
    }
}