java父子类执行顺序

1.Parent 父类:

public class Parent {
    static {
        System.out.println("我是父类静态代码块!");
    }

    {
        System.out.println("我是父类非静态代码块!");
    }

    static void static_method() {
        System.out.println("我是父类静态方法!");

    }

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

    Parent(String arg) {
        System.out.println("我的父类有参构造方法,参数:" + arg);
    }

    public void say() {
        System.out.println("父类一般方法");
    }

}

2.Son子类:

public class Son extends Parent {
    static {
        System.out.println("我是子类类静态代码块!");
    }

    {
        System.out.println("我是子类非静态代码块!");
    }

    static void static_method() {
        System.out.println("我是子类静态方法!");

    }

    Son() {
        System.out.println("我是子类无参构造方法");
    }

    Son(String arg) {
        System.out.println("我的子类有参构造方法,参数:" + arg);
    }

    @Override
    public void say() {
        System.out.println("子类一般方法");
    }


}

3.test:

public class Test {
    public static void main(String[] args) {
        Parent parent=new Parent();
        //Son son= new Son();
       // Parent son2=new Son();
    }
}

首先

1.创建父类  Parent parent=new Parent()

打印结果:

jdk1.8\jre\lib\rt.jar;F:\Idea代码存放地址\Parent_test\out\production\Parent_test parent_son.Test
我是父类静态代码块!
我是父类非静态代码块!
我是父类无参构造方法

执行顺序为: 静态块->非静态块->无参构造

2.创建父类  Parent parent=new Parent("1")

我是父类静态代码块!
我是父类非静态代码块!
我的父类有参构造方法,参数:1

执行顺序为: 静态块->非静态块->有参构造

3.直接调用父类 静态方法 static_method();

public class Test {
    public static void main(String[] args) {
       // Parent parent=new Parent("1"); 不创建实例,直接调用静态方法
            Parent.static_method();
        //Son son= new Sonp();
       // Parent son2=new Son();
    }
}

结果:

我是父类静态代码块!
我是父类静态方法!

执行顺序为: 静态块->静态块静态方法  (只加载类静态,非静态的属于类的实例,因此不创建!)

4.创建子类,Son son= new Son();

public class Test {
    public static void main(String[] args) {
      //  Parent parent=new Parent("1");
        //    Parent.static_method();
        Son son= new Son();
       // Parent son2=new Son();
    }
}

结果:

我是父类静态代码块!
我是子类类静态代码块!
我是父类非静态代码块!
我是父类无参构造方法
我是子类非静态代码块!
我是子类无参构造方法

执行顺序为:父类静态块->子类静态块->父类非静态块->父类无参构造->子类非静态构造->子类无参构造

   首先依次加载父类和子类静态块(属于类的先加载),再去加载实例化代码(非静态和构造)

5.创建子类有参,Son son= new Son("1");

执行结果:

我是父类静态代码块!
我是子类类静态代码块!
我是父类非静态代码块!
我是父类无参构造方法
我是子类非静态代码块!
我的子类有参构造方法,参数:1

执行顺序可以看到和无参构造差不多,但是它执行的都是父类无参构造函数

6.直接调用子类静态方法,Son.static_method();

我是父类静态代码块!
我是子类类静态代码块!
我是子类静态方法!

执行顺序:父类静态块->子类静态块->子类静态方法

7.子类向上转型,Parent son2=new Son();

我是父类静态代码块!
我是子类类静态代码块!
我是父类非静态代码块!
我是父类无参构造方法
我是子类非静态代码块!
我是子类无参构造方法

执行顺序:父静态块->子静态块->父非静态块->父无参->子非静态块-子无参(或有参)构造

-----------------------------------------------------------------------

总结:

创建对象,一般先加载静态块-非静态块-构造方法,子类的话是先加载父静态-子静态-父非静态块-父无参构造-子非静态块-子无参或者有参构造;

调用静态方法,先加载静态代码块  再调用静态方法

最后,一般方法是最后执行的