Java｜面向对象（下）-- 代码块

作用

用来初始化类、对象。代码块只能使用 static 修饰

静态代码块

• 内部可以有输出语句
• 随着类的加载而执行，而且只执行一次
• 作用：初始化类的信息。
• 如果一个类中，定义类多个静态代码块，则按照声明的先后顺序执行
• 静态代码块的执行，优先于非静态代码块的执行
• 静态代码块内只能调用静态的属性、静态的方法、不能调用非静态的结构

非静态代码块

• 内部可以有输出语句
• 随着对象的创建而执行
• 每创建一个对象，就执行一次非静态代码块
• 作用：可以在创建对象时，对对象的属性等进行初始化
• 如果一个类中，定义类多个非静态代码块，则按照声明的先后顺序执行
• 非静态代码块可以调用静态的属性，静态的方法，或非静态的属性，非静态的方法

代码块示例

package com.base.learn;

public class BlockTest {
    public static void main(String[] args) {
        String desc = Person.desc;
        System.out.println("---------");
        Person p1 = new Person();
    }
}

class Person {
    // 属性
    String name;
    int age;
    static String desc = "人类";

    // 构造器
    public Person() {

    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 代码块
    static {
        System.out.println("Hello, Static Block-1");
        desc = "hello,";
    }
    static {
        System.out.println("Hello, Static Block-2");
    }

    {
        System.out.println("Hello, Block");
        desc = "heihei";
        eat();
    }

    // 方法
    public void eat() {
        System.out.println("吃饭");
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

/*
Hello, Static Block-1
Hello, Static Block-2
---------
Hello, Block
吃饭
*/

代码块的执行顺序

通过下面这两段代码，搞清楚代码块的执行顺序

package com.base.learn;

/**
 * 判断加载顺序
 * 由父及子，静态先行
 */

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

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

    public Root() {
        System.out.println("Root 空参构造器");
    }
}

class Mid extends Root {
    static {
        System.out.println("Mid 的静态代码块");
    }

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

    public Mid() {
        System.out.println("Mid 空参构造器");
    }

    public Mid(String msg) {
        this();
        System.out.println("Mid 带参构造器 " + msg);
    }
}

class Leaf extends Mid {
    static {
        System.out.println("Leaf 的静态代码块");
    }

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

    public Leaf() {
        super("天天向上");
        System.out.println("Leaf 空参构造器");
    }
}


public class LeafTest {
    public static void main(String[] args) {
        new Leaf();
        System.out.println("--------------");
        new Leaf();
    }
}
/*
Root 的静态代码块
Mid 的静态代码块
Leaf 的静态代码块
Root 的普通代码块
Root 空参构造器
Mid 的普通代码块
Mid 空参构造器
Mid 带参构造器 天天向上
Leaf 的普通代码块
Leaf 空参构造器
--------------
Root 的普通代码块
Root 空参构造器
Mid 的普通代码块
Mid 空参构造器
Mid 带参构造器 天天向上
Leaf 的普通代码块
Leaf 空参构造器
 */

package com.base.learn;

/**
 *
 */

class Father {
    static {
        System.out.println("111111111");
    }

    {
        System.out.println("222222222");
    }

    public Father() {
        System.out.println("333333333");
    }
}

public class SonTest extends Father {
    static {
        System.out.println("444444444");
    }

    {
        System.out.println("555555555");
    }

    public SonTest() {
        System.out.println("666666666");
    }

    public static void main(String[] args) {
        System.out.println("777777777");
        System.out.println("******************");
        new SonTest();

    }
}
/*
111111111
444444444
777777777
******************
222222222
333333333
555555555
666666666
*/

变量赋值初始化过程

package com.base.learn;

/**
 * 对属性可以赋值的位置：
 * 1. 默认初始化
 * 2. 显示初始化
 * 3. 构造器中初始化
 * 4. 有了对象以后，可以通过"对象.属性" 或 "对象.方法"的方式进行赋值
 * 5. 在代码块中赋值
 *
 * 执行先后顺序：1 -- 2 / 5 -- 3 -- 4
 */
public class Order1 {
    public static void main(String[] args) {
        Ord  ord = new Ord();
        System.out.println(ord.orderId);
    }
}

class Ord {
    {
        orderId = 4;
    }
    int orderId = 3;
}