java - 代码块

代码块

基本介绍

代码块又称为初始化块，属于类中的成员，即类的一部分，和方法类似。将逻辑语句封装在方法体中，通过{}包围起来。

但和方法不同，没有方法名、没有返回、没有参数。只有方法体，而且不用通过对象或类显式的调用，而是加载类时，或创建对象时隐式调用。

基本语法

[修饰符]{
    代码;
};

注意：

1、修饰符 可选，要写的话，只能写static；

2、代码块分为两类，使用static 修饰的叫静态代码块，没有static修饰的，叫非静态代码块；

3、逻辑语句可以为任意逻辑语句(输入、输出、方法调用、循环、判断等等)；

4、最后的分号可以写，也可以省略。

5、代码块调用的顺序优先于构造器。这样不管我们调用哪个构造器，只要是创建对象，都会先调用代码块中的内容。

代码块的好处

1、相当于另外一种形式的构造器(对构造器的补充机制)，可以做初始化的操作。

2、场景：如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性。

代码块使用注意事项和细节

1、static代码块也叫静态代码块，作用是对类进行初始化，而且它随着类的加载而执行，且只会执行一次，不轮在什么文件中调用，只会加载一次，父类也会进行加载，如果是普通代码块，则每创建new一个对象，就会执行一次。即普通代码块是对类构造器的补充。

2、类在什么时候会被加载**【重要】**：

• 创建对象实例时(new)

• 创建子类对象实例，父类也会被加载

• 使用类的静态成员时(静态方法、静态属性)，static代码块会被调用，普通代码块不会执行。

package com.zhangch.static_;

public class CodeBlockDetails01 {
    public static void main(String[] args) {
        System.out.println(A.a);
    }
}
class B{
    static {
        System.out.println("B类加载");
    }
}

class A extends B{
    public static int a = 100;

    static {
        System.out.println("A类被加载");
    }
}

3、普通的代码块，在创建对象实例时，会被隐式调用。被创建一次，就会调用一次，如果只是使用类的静态成员时，则普通代码块并不会执行。

4、**静态代码块只能直接调用静态成员(静态属性和静态方法)，**普通代码块可以调用任意成员。

0386_韩顺平Java_代码块使用细节1_哔哩哔哩_bilibili

重点

创建一个对象时，一个类 调用顺序是：（重点、难点）

一：调用静态代码块和静态属性初始化。(此时为：类加载，初次使用类的时候，在内存中加载这些类的信息)

1、调用静态代码块和静态属性/初始化后，将类的各个属性(普通属性/静态属性)和方法在方法区中完成默认加载。即默认初始化。

注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序执行。

二：调用构造方法。(每生成一个对象，都会进行这么一番操作，前提是，类的信息已经加载，不然就从一开始。)

1、先调用普通代码块和普通属性的初始化。

1、先使用super调用父类的构造器，然后对父类的普通代码块和普通属性进行初始化，此时，对普通属性的初始化，即显式初始化。

2、继续运行父类的构造器，直至父类构造器所有代码运行结束，此时，通过构造器参数对普通属性赋值，即构造器初始化。

注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按照定义的顺序进行调用

2、当父类的构造方法运行完毕，再进行自类的构造器方法。

1、super运行结束后，将子类的普通属性和普通代码块进行显示初始化，运行子类的构造器，

2、再运行构造器底下的代码，比如参数对属性赋值等等，进行构造器初始化。

package com.zhangch.static_;

public class CodeBlockDetail02 {
    public static void main(String[] args) {
        BB aa = new AA(100, 23);

    }
}

class BB{
    public String name = "zhang";
    static {
        System.out.println("B类静态代码块");
    }
    {
        System.out.println("B类普通代码块");
    }

    public BB(String name) {
        super();
        this.name = name;
        System.out.println("BB的构造器");
    }
}

class AA extends BB{
    {
        System.out.println("AA普通初始化");
    }

    public int dd = getD();
    public int b = 100;
    public int z = 12323;

    // 静态属性初始化
    public static int zhang = 1000;
    public static int a = getA();

    static {
        System.out.println("a的值为:" + a);
        System.out.println("静态代码块");
    }

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

    public int getD(){
        System.out.println("调用getD方法");
        System.out.println("getD中b的值为" + b);
        return 20;
    }

    public AA(int dd, int b) {
        super("aa");
        System.out.println("构造器");
        this.dd = dd;
        this.b = b;
    }
}

总结：其实记住，在构造器中的代码运行时，会先运行super()和调用普通代码块。只不过没显式的写出来代码。

package com.hspedu.codeblock_;

public class CodeBlockDetail04 {
    public static void main(String[] args) {
        //老师说明
        //(1) 进行类的加载
        //1.1 先加载 父类 A02 1.2 再加载 B02
        //(2) 创建对象
        //2.1 从子类的构造器开始
        //new B02();//对象

        new C02();
    }
}

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");//(1)
        return 10;
    }

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

    public A02() {//构造器
        //隐藏
        //super()
        //普通代码和普通属性的初始化......
        System.out.println("A02的构造器");//(7)
    }

}

class C02 {
    private int n1 = 100;
    private static  int n2 = 200;

    private void m1() {

    }
    private static void m2() {

    }

    static {
        //静态代码块，只能调用静态成员
        //System.out.println(n1);错误
        System.out.println(n2);//ok
        //m1();//错误
        m2();
    }
    {
        //普通代码块，可以使用任意成员
        System.out.println(n1);
        System.out.println(n2);//ok
        m1();
        m2();
    }
}

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");//(3)
        return 10;
    }

    public int getVal04() {
        System.out.println("getVal04");//(8)
        return 10;
    }
    //一定要慢慢的去品..
    public B02() {//构造器
        //隐藏了
        //super()
        //普通代码块和普通属性的初始化...
        System.out.println("B02的构造器");//(10)
        // TODO Auto-generated constructor stub
    }
}