Java 实例初始化和类初始化

非静态代码块:
声明的格式:
[修饰符]class 类名{
{(非静态代码块)}
}

非静态代码执行时间:
1 在[每次]创建对象的时候执行
2 比构造器早执行

实例初始化:(创建对象时,对对象进行初始化的操作
1 对成员变量显式赋值
2 执行非静态代码块
3 执行构造器
(其中1与2按代码排列顺序执行) 
因此实例初始化方法中包含:
成员变量的显式赋值
非静态代码块
构造器
                                        ↓和构造器的形参列表一致
Java编译器把这三个部分的代码 合成一个叫做<init>(形参列表)的实例初始化方法
即.class字节码中,没有构造器的概念
(有几个构造器,就会有几个实例初始化方法,创建对象调用构造器时,执行的就是对应的实例初始化方法)

==================================================
静态代码块:
静态代码块
<1>每一个类的静态代码块只会执行一次
<2>静态代码块在第一次使用这个类时执行(在类初始化时执行)

类初始化(执行类初始化方法): ()
一个类只有一个, 也是由编译器编译生成的, 由两部分代码组成:
静态代码块
静态变量的显式赋值
(↑按顺序执行)

☆在继承时,一个类初始化时会先检查它的父类是否初始化,如果父类没有初始化,那么会先初始化父类.(对于一个类,初始化只会执行一次)
(静态方法不能被重写)

两者之间:
先进行类初始化,再进行实例初始化
 

public class TestBlock {
    public static void main(String[] args) {

    testUSE a = new testUSE();
    }
}

class testUSE{
    private int a = assign();//显式赋值

    public int assign(){
//用来判断显式赋值执行的时间
        System.out.println("我执行了");
        return 0;
    }
    public testUSE() {
        System.out.println("无参构造");
    }

    {
        System.out.println("非静态代码块");
    }

    public testUSE(int a) {
        this.a = a;
        System.out.println("有参构造");
    }
}

输出结果为:

我执行了
非静态代码块
无参构造

 

public class InitDemo2 {
    public static void main(String[] args) {
        Fu f = new Fu();
        System.out.println("=============");
        Zi z = new Zi();
    }
}

class Fu{
    {
        System.out.println("父类非静态代码块");
    }

    public Fu() {
        System.out.println("父类无参构造");
    }
}

class Zi extends Fu{
    {
        System.out.println("子类非静态代码块");
    }

    public Zi() {
        System.out.println("子类无参构造");
    }
}

super()/super(实参)其实调用的是父类的实例初始化方法
super()/super(实例列表)在子类构造器首行,实际发生在子类实例初始化方法首行

因此, 输出结果为:

父类非静态代码块
父类无参构造
=============
父类非静态代码块
父类无参构造
子类非静态代码块
子类无参构造