java初始化顺序

一页比较形象的课件：

1.如果没有子类父类的关系，那么就是
静态变量、静态初始化块–>非静态变量、初始化块–>构造方法

2.如果有子类父类关系，那么就是
静态（父）–>静态（子）–>非静态（父）–>构造器（父）–>非静态（子）–>构造器（子）。

3.父类构造器先于子类构造器执行的原因如下：如果不初始化父类，而是先初始化子类，那么子类想要调用父类的方法时会发生异常。jvm为了防止这种情况，会先初始化父类，也就是如果在创建子类对象前没有创建一个父类对象，那么会先初始化父类，也就是先调用父类的构造器构造一个父类对象，然后才是调用子类的构造方法。

下面是一些题目及个人分析：
1.非父子类的初始化：

class A {
    int value;
    static A a1 = new A(1);
    public A(int i) {
        System.out.println("initialize A"+i);
        value = i;
    }
    public A(A a) {
        System.out.println("copy from A"+a.value);
        value = a.value;
    }
    static A a2 = new A(2);
}
class B {
    A a8;
    // A a7 = new A(a6);
    A a6 = new A(6);
    static A a3 = new A(3);
    static A a4;
    static {
        a4 = new A(4);
    }
    static A a5 = new A(5);
    public B(int i) {
        System.out.println("initialize B"+i);
        a8 = new A(8);
    }
    A a7 = new A(a6);
}
public class Initialization {
    static B b1 = new B(1);
    static B b2;
    public static void main(String[] args) {
        System.out.println("main begins");
        A a9 = new A(9);
        b2 = new B(2);
        System.out.println("main ends");
    }
}

输出：(原输入是没有注释和空行的，这里是为了方便分块解释输出的由来)

/*A类的静态块
initialize A1
initialize A2
*/

/*B类的非静态块
initialize A3
initialize A4
initialize A5
*/

/*B类的非静态块
initialize A6
copy from A6
*/

/*B类的构造方法
initialize B1
initialize A8
*/

/*main方法的第一行输出
main begins
*/

/*A类的构造方法，由于A类没有非静态块，所以再次new的时候只有A类的构造方法起作用
initialize A9
*/

/*B类非静态块
initialize A6
copy from A6
*/

/*B类构造方法
initialize B2
initialize A8
*/

/*main的第二行输出
main ends
*/

我现在来解释一下代码的运行过程：
1）进入public类，执行静态块：

static B b1 = new B(1);
static B b2;

静态块的第一行new了一个B类，于是去到B类，依次执行三个静态语句

    static A a3 = new A(3);
    static A a4;
    static {
        a4 = new A(4);
    }
    static A a5 = new A(5);

第一个静态语句new了一个A类，我们看到A类，并执行两个静态语句，

    static A a1 = new A(1);
    public A(int i) {
        System.out.println("initialize A"+i);
        value = i;
    }
    public A(A a) {
        System.out.println("copy from A"+a.value);
        value = a.value;
    }
    static A a2 = new A(2);

第一个静态语句new了一个A类，此时调用构造方法，于是就得到了第一行的输出：

initialize A1

然后执行第二个静态语句，就得到了第二行输出：

initialize A2

至此A类的静态语句执行完毕，以后再new A（i）的时候就不会再执行这两句了，

2）于是回到B类，执行static A a3 = new A(3);，也就是initialize A3，然后初始化A4，初始化A5，也就是第3至5行输出。至此，B类的静态块执行完毕，可以执行B类的的非静态语句了：

 A a6 = new A(6);
 A a7 = new A(a6);

于是得到：

initialize A6
copy from A6

这两行输出。
3）然后执行B类的构造方法，得到以下两行输出：

initialize B2
initialize A8

4）接着进入main方法，main方法的两个输出就不解释了
5）A a9 = new A(9);这一句只执行A类的构造方法，因为静态块只执行一遍，A类又没有非静态块，于是只有一行输出：

initialize A9

6）最后执行new B(2),先执行B类的非静态块，然后执行B类的构造方法，也就是：

/*B类非静态块
initialize A6
copy from A6
*/

/*B类构造方法
initialize B2
initialize A8
*/

这道题就根据我的理解先讲到这，如果有什么不对的欢迎留言指出

2.父子类：

//Animal.java
public class Animal {
    public Animal(){
        System.out.println("I am an animal");
    }
}

//Dog.java
public class Dog extends Animal{
    public Dog(){
        System.out.println("I am a dog");
    }
}

//AnimalTest.java
public class AnimalTest {
    public <T,S extends T> T testDemo(T t,S s){
        System.out.println("I am type T and my type is "+t.getClass().getName());
        System.out.println("I am type S and my type is "+s.getClass().getName());
        return t;
    }
    public static void main(String[] args){
        AnimalTest test=new AnimalTest();
        Dog dog=new Dog();
        Animal animal=new Animal();
        Animal animal1=test.testDemo(animal,dog);
    }
}

上面这段代码的输出为：

这是原因：
哈哈父类构造器先于子类构造器执行的原因如下：如果不初始化父类，而是先初始化子类，那么子类想要调用父类的方法时会发生异常。jvm为了防止这种情况，会先初始化父类，也就是如果在创建子类对象前没有创建一个父类对象，那么会先初始化父类，也就是先调用父类的构造器构造一个父类对象，然后才是调用子类的构造方法。