非静态代码块(非static初始化块)&静态代码块(static初始化块)

非静态代码块：

TestOrder：

package com.aff.singleton;

/*
类的第四个成员：初始化块（代码块）
代码块: 如果有修饰的话只能使用static
分类：非静态代码块：1.可以对类的属性(静态&非静态)进行初始化操作，同时可以调用本类声明的方法(静态&非静态)
                                   2.里面可以有输出语句
                                   3.一个类中可以有多个非静态代码块，多个代码块之间按顺序结构执行
                                   4.每创建一个类的对象，非静态代码块就会加载一次
                                   5.非静态代码块的执行要早于构造器
           静态代码块：1.里面可以有输出语句
                                2.随着类的加载而加载，而且只被加载一次
                                3.多个静态代码块按照顺序执行
                                4.静态代码块的执行要早于非静态代码块的执行
                                5.静态代码块中只能执行静态的结构(类属性， 类方法) ，静态的里面不能调用非静态的

关于属性赋值的操作：①默认的初始化
                                   ②显式的初始化或代码块的初始化（此处的两个结构按照顺序执行）
                                   ③构造器中
                                   ④通过方法对对象的相应属性进行修改
*/
public class TestOrder {
    public static void main(String[] args) {
        Order o1 = new Order();
        System.out.println(o1);

        Order o2 = new Order();
        System.out.println(o2);
    }
}

class Order {
    private int orderId = 1001;
    private String orderName;

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

    // 非静态代码块（初始化块）
    {
        orderId = 1002;
        orderName = "aa";
        System.out.println("非静态代码块1");
    }
    {
        System.out.println("非静态代码块2");
    }

    public Order() {
        super();
    }

    public Order(int orderId, String orderName) {
        super();
        this.orderId = orderId;
        this.orderName = orderName;
    }

    public int getOrderId() {
        return orderId;
    }

    public void setOrderId(int orderId) {
        this.orderId = orderId;
    }

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }

    @Override
    public String toString() {
        return "Order [orderId=" + orderId + ", orderName=" + orderName + "]";
    }
}

输出结果：

静态代码块1
非静态代码块1
非静态代码块2
Order [orderId=1002, orderName=aa]
非静态代码块1
非静态代码块2
Order [orderId=1002, orderName=aa]

练习执行顺序的先后

TestLeaf：

package com.aff.singleton;

//执行顺序 static的先，父类的先，
//构造器晚于非静态的代码块
public class TestLeaf {
    public static void main(String[] args) {
        new Leaf();
        System.out.println();
        new Leaf();//静态的没了

    }
}

class Root {
    static {
        System.out.println("Root的静态初始化块");
    }
    {
        System.out.println("Root的普通初始化块");
    }

    public Root() {
        super();
        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调用同一类中重载的构造器
        this();
        System.out.println("Mid的带参数的构造器，其参数值：" + msg);
    }
}

class Leaf extends Mid {
    static {
        System.out.println("Leaf的静态初始化块");
    }
    {
        System.out.println("Leaf的普通初始化块");
    }

    public Leaf() {
        // 通过super调用父类中有一个字符串参数的构造器
        super("AAAA");
        System.out.println("Leaf的无参构造器");
    }
}

输出结果：

Root的静态初始化块
Mid的静态初始化块
Leaf的静态初始化块
Root的普通初始化块
Root的无参构造器
Mid的普通初始化块
Mid的无参构造器
Mid的带参数的构造器，其参数值：AAAA
Leaf的普通初始化块
Leaf的无参构造器

Root的普通初始化块
Root的无参构造器
Mid的普通初始化块
Mid的无参构造器
Mid的带参数的构造器，其参数值：AAAA
Leaf的普通初始化块
Leaf的无参构造器