Java中static成员变量、成员变量、static代码块、代码块、构造方法的执行顺序

执行顺序的规则：

一、先执行内部静态对象的构造方法，如果有多个按定义的先后顺序执行；静态对象在构造的时候也是也先执行其内部的静态对象。

二、再调用父类的构造方法（父类还有父类的话，从最开始的基类开始调用），如果没有明显指定调用父类自定义的构造方法，那么编译器会调用默认的父类构造方法super()。但是如果要调用父类自定义的构造方法，要在子类的构造方法中明确指定。

三、按声明顺序将成员引用对象变量初始化。

四、最后调用自身的构造方法。

五、同一个类中的static代码块，代码块，构造函数的执行顺序此顺序执行，static代码块与代码块的区别是static代码块只执行一次。

 

下面以一个例子来说明代码如下：

package com.dxz;

class Animal {
    String name;

    Animal() {
        System.out.println("class Animal default construct");
    }

    Animal(String name) {
        this.name = name;
        System.out.println(name + " class Animal construct");
        printNumber();
    }

    public void printNumber() {

    }
}
package com.dxz;

public class Fish extends Animal {
    Fish() {  
        System.out.println("class Fish");  
    }
}

package com.dxz;

public class GoldFish extends Fish {
    GoldFish() {  
        System.out.println("class GoldFish");  
    }  
}

package com.dxz;

public class Cat {
    Cat(){  
        System.out.println("class cat");  
    }
}


package com.dxz;

public class Rabbit {
    private static int number;
    private static Cat cat = new Cat();//静态成员先执行
    
    public Rabbit() {  
        number++;  
        System.out.println(number + "class rabbit");  
    }
    
    static {
        System.out.println("static Rabbit");
    }
    
    {
        System.out.println("I'm a Rabbit");
    }
}
package com.dxz;

public class Dog extends Animal {
    public int dogNumber;  
    private GoldFish goldFish = new GoldFish();  
    static  Rabbit blackRabbit = new Rabbit();   
    static  Rabbit whiterabbit = new Rabbit();   
      
    public Dog() {
        super("super Tom");  
        System.out.println("class Dog");  
        dogNumber = 10;  
        System.out.println("The dog's number is:" + dogNumber);  
    }  
      
    public void printNumber(){  
        System.out.println("The dog's number is:" + dogNumber);  
    }  
}
package com.dxz;

public class TestInheritanceConstructor extends Animal {
    public static void main(String[] args){ 
        System.out.println("---------------begin---------");
        new Dog(); 
    }  
}

//结果：
1:---------------begin---------
2:class cat 
3:static Rabbit
4:I'm a Rabbit
5:1class rabbit
6:I'm a Rabbit
7:2class rabbit
8:super Tom class Animal construct
9:The dog's number is:0
10:class Animal default construct
11:class Fish
12:class GoldFish
13:class Dog
14:The dog's number is:10

解释：

输出第2行：class cat  是因为Dog类中有静态成员。而静态成员所在的类Rabbit中又有静态成员。所以最先执行它。验证第一句。

输出第5、7行：1class rabbit 和 2class rabbit 是执行类Rabbit构造函数。

输出第3、4、5、6、7行：同一个类中static代码块，代码块，构造函数的执行顺序及static代码块只执行一次。验证第五句。

输出第8行：super Tom class Animal construct 执行父类的构造函数，因为用super("")。

输出第9行：The dog's number is:0 可以看出子类的dogNumber还是默认值0

输出第10、11、12行：class Animal default construct和 class Fish 和 class GoldFish是构造goldFish引用对象类型。验证第三句。

输出第13、14行：class Dog  和The dog's number is:10是执行自己的构造函数。