Java代码块

普通代码块

普通代码块在对象创建时执行，创建一个对象就会执行一次，可把构造函数中的冗余代码放到普通代码块中

public class Test {
    public void method() {
        // 普通代码块
        {
            int x = 10;
            System.out.println(x);
        }
        public method(){

        }
    }
}

普通代码块的特点

• 普通代码块没有访问修饰符，也没有名称，只是一个用花括号括起来的代码段。
• 普通代码块在定义时立即执行，执行完毕后就会被销毁。
• 普通代码块可以访问所在作用域内的变量，但不能被外部作用域访问。
• 普通代码块常用于在方法中创建临时变量或执行一些需要临时作用域的操作。

静态代码块

静态代码块在类第一次加载时执行，并且只会执行一次。

public class Test {
    static {
        System.out.println("静态代码块");
    }
    
    public static void main(String[] args) {
        Test t = new Test();
    }
}

静态代码块的特点

• 静态代码块使用关键字static进行修饰，不需要被调用，会在类加载时自动执行。
• 静态代码块只会执行一次，且在类加载时执行，先于构造方法执行。
• 静态代码块可以访问静态成员变量和静态方法，但不能访问非静态成员变量和非静态方法。
• 静态代码块常用于进行静态变量的初始化或加载静态资源的操作。

调用顺序

无继承

在创建一个对象时，在一个类调用的顺序是：

1）调用静态代码块和静态属性初始化（两者优先级一致）。

2）调用普通代码块和普通属性的初始化。

3）调用构造方法。

代码：

public class Test {

    public static void main(String[] args) {
        A a = new A();
    }

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

    private int n2 = getN2();//普通属性的初始化


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


    //静态属性的初始化
    private static int n1 = getN1();

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

    public int getN2() { //普通方法/非静态方法
        System.out.println("getN2 被调用...");
        return 200;
    }
}

结果：

有继承

在创建对象子类会先调用父类的代码块和构造方法

public class Test {

    public static void main(String[] args) {
        AAA a = new AAA();
    }

}
class AAA { //父类 Object
    {
        System.out.println("AAA 的普通代码块");
    }
    public AAA() {
//(1)super()
//(2)调用本类的普通代码块
        System.out.println("AAA() 构造器被调用	");
    }
}


class BBB extends AAA	{
    {
        System.out.println("BBB 的普通代码块...");
    }
    public BBB() {
//(1)super()
//(2)调用本类的普通代码块
        System.out.println("BBB() 构造器被调用	");
    }
}

若子类和父类同时有静态代码块，普通代码块和构造方法时的执行顺序为：

1）父类的静态代码块和静态属性

2）子类的静态代码块和静态属性

3）父类的普通代码块和普通属性

4）父类的构造方法

5）子类的普通代码块和普通属性

6）子类的构造方法

代码：

public class Test {

    public static void main(String[] args) {
        B02 a = new B02();
    }

}
class A02 { //父类
    private static int n1 = getVal01();
    static {
        System.out.println("A02 的一个静态代码块..");//(2)
    }
    {
        System.out.println("A02 的第一个普通代码块..");//(5)
    }
    public int n3 = getVal02();//普通属性的初始化
    public static int getVal01() {
        System.out.println("getVal01");
        return 10;
}

    public int getVal02() { System.out.println("getVal02");
        return 10;
    }


    public A02() {//构造器
        System.out.println("A02 的构造器");//(7)
    }


}


class B02 extends A02 { //子类


    private static int n3 = getVal03();


    static {
        System.out.println("B02 的一个静态代码块..");//(4)
    }

    public int n5 = getVal04();

    {
        System.out.println("B02 的第一个普通代码块..");//(9)
    }


    public static int getVal03() {
        System.out.println("getVal03");
        return 10;
    }


    public int getVal04() {
        System.out.println("getVal04");
        return 10;
    }

    public B02() { //构造器
        System.out.println("B02 的构造器");
    }
}

结果：