Java中父类、子类加载顺序

父类子类加载顺序

• 1、父类的静态变量和静态代码块赋值(按照声明顺序)
• 2、自身的静态变量和静态代码块赋值(按照声明顺序)
• 3、main方法
• 4、父类的成员变量和块赋值(按照声明顺序)
• 5、父类的构造器赋值
• 6、自身成员变量和块赋值(按照声明顺序)
• 7、自身的构造器赋值
• 8、静态方法，实例方法只有在调用的时候才会去赋值

public class TestStaticAndConstruct {

    public static int width = 100;

    public static int count;

    static{
        //静态代码块在类加载的时候执行一次，且只执行一次
        System.out.println("父类静态代码块");
    }

    {
        //构造代码块在构造对象的时候才会被调用，优先于构造方法执行,不因构造方法的不同而改变，每次new对象都会执行
        System.out.println("父类构造代码块");
    }

    public TestStaticAndConstruct() {

        System.out.println("父类无参构造方法");
    }

    public TestStaticAndConstruct(String str) {
        this.str = str;
        System.out.println("父类有参构造方法");
    }

    public String str;

    public static void main(String[] args) {

        TestStaticAndConstruct ts1 = new TestStaticAndConstruct("有参构造");    //每次new对象都会执行构造代码块
        TestStaticAndConstruct ts = new TestStaticAndConstruct();   //每次new对象都会执行构造代码块

        /**
         * 打印结果：
         *  父类静态代码块
         *  父类构造代码块
         *  父类有参构造方法
         *  父类构造代码块
         *  父类无参构造方法
         */
    }
}

class A extends TestStaticAndConstruct{

    static {
        System.out.println("子类静态代码块1");
    }
    {
        System.out.println("子类构造代码块");
    }

    public String str;

    public A(){
        System.out.println("子类无参构造");
    }
    public A(String str, String str1) {
        super(str);
        this.str = str1;
        System.out.println("子类有参构造");
    }
    static {
        System.out.println("子类静态代买块2");
    }

    public static void main(String[] args) {

        System.out.println("main start....");
        A a = new A("hh","hh");

        {
            System.out.println("普通代码块");
        }

        /**
         * 打印结果：
         *  父类静态代码块
         *  子类静态代码块1
         *  子类静态代买块2
         *  main start....
         *  父类构造代码块
         *  父类有参构造方法
         *  子类构造代码块
         *  子类有参构造
         *  普通代码块
         */
    }
}