一、类初始化

1、一个类要创建实例需要先加载并初始化该类

（1）main方法所在的类需要先加载和初始化

class Father{
    private static int i = method();

    private static int method() {
        System.out.println("（2）");
        return 1;
    }
}

public class Son{
    private static int i = method();

    private static int method() {
        System.out.println("（1）");
        return 1;
    }

    public static void main(String[] args) {

    }
}

输出结果：
（1）

上述的例子Father类和Son类之间没有继承关系，但是Son类当中有main方法，因此根据上述规则“main方法所在的类需要先加载和初始化”，可得结果和输出结果相符，都是输出（1），且这时候只有类初始化过程。

2、一个子类要初始化需要先初始化父类

class Father{
    private static int i = method();

    private static int method() {
        System.out.println("（2）");
        return 1;
    }
}

public class Son extends Father{
    private static int i = method();

    private static int method() {
        System.out.println("（1）");
        return 1;
    }

    public static void main(String[] args) {

    }
}

输出结果：
（2）
（1）

这个例子和上一个例子相似，唯一的不同是Son类继承了Father类，根据规则2，可以发现父类的静态变量先行初始化，所以输出结果是（2）然后再输出（1）。

3、一个类初始化就是执行()方法

（1）()方法由静态类变量显示赋值代码和静态代码块组成

（2）类变量显示赋值代码和静态代码块代码从上到下顺序执行

（3）()方法只执行一次

根据规则3，我们可以设置下列对造组，由下列试验得出的结果也佐证了规则3。

public class Son{
    private static int j = method2();
    private static int i = method1();
    
    private static int method2() {
        System.out.println("（2）");
        return 0;
    }

    private static int method1() {
        System.out.println("（1）");
        return 0;
    }

    public static void main(String[] args) {

    }
}
输出结果：
（2）
（1）

public class Son{
    private static int i = method1();  //调换i和j的声明顺序
    private static int j = method2();

    private static int method2() {
        System.out.println("（2）");
        return 0;
    }

    private static int method1() {
        System.out.println("（1）");
        return 0;
    }

    public static void main(String[] args) {

    }
}
输出结果：
（1）
（2）

二、实例初始化

1、实例初始化就是执行()方法

（1）()方法可能重载有多个，有几个构造器就有几个方法

（2）()方法由非静态实例变量显示赋值代码和非静态代码块、对应构造器代码组成

（3）非静态实例变量显示赋值代码和非静态代码块代码从上到下顺序执行，而对应构造器的代码最后执行

根据上述规则，还可以再设立对照组，可以发现非静态实例变量和非静态代码块的初始化顺序是按从上到下的顺序执行的。

class Father{
    {
        System.out.println("（2）");
    }
    private int anInt = method();

    private int method() {
        System.out.println("（1）");
        return 0;
    }
}

public class Son extends Father{
    {
        System.out.println("（4）");
    }
    private int anInt = method();

    private int method() {
        System.out.println("（3）");
        return 0;
    }

    public static void main(String[] args) {
        Son son = new Son();
    }
}
输出结果：
（2）
（1）
（4）
（3）

class Father {

    private int anInt = method();

    {
        System.out.println("（2）");
    }

    private int method() {
        System.out.println("（1）");
        return 0;
    }
}

public class Son extends Father {

    private int anInt = method();

    {
        System.out.println("（4）");
    }

    private int method() {
        System.out.println("（3）");
        return 0;
    }

    public static void main(String[] args) {
        Son son = new Son();
    }
}
输出结果：
（1）
（2）
（3）
（4）

（4）每次创建实例对象，调用对应构造器，执行的就是对应的方法

（5）方法的首行是super()或super(实参列表)，即对应父类的方法

根据上述第5点，可以发现父类的构造方法都是先于子类的构造方法执行，在初始化子类实例的时候，因为其实子类的构造方法当中固定有一个super()方法，用于执行父类的构造方法。

class Father{
    Father(){
        System.out.println("Father的无参构造方法");
    }
}

public class Son extends Father{
    Son(){
        System.out.println("Son的无参构造方法");
    }

    public static void main(String[] args) {
        Son son = new Son();
    }
}
输出结果：
Father的无参构造方法
Son的无参构造方法

三、方法重写对实例初始化的影响

（1）父类实例变量初始化当中用到的是子类重写的方法

class Father {

    private int anInt = method();

    {
        System.out.println("（2）");
    }

    public int method() {
        System.out.println("（1）");
        return 0;
    }
}

public class Son extends Father {

    private int anInt = method();

    {
        System.out.println("（4）");
    }

    public int method() { //这里重写了method()方法
        System.out.println("（3）");
        return 0;
    }

    public static void main(String[] args) {
        Son son = new Son();
    }
}
输出结果：
（3）
（2）
（3）
（4）