JAVA类加载顺序

加载顺序：

父类静态变量，父类静态代码块->子类静态变量，子类静态代码块->父类成员变量，父类非静态代码块->父类构造方法->子类成员变量，子类非静态代码块，子类构造方法。

?1:同级资源父类优于子类。（用到子类静态变量时也会先加载父类静态资源）
?2:静态变量和静态代码块根据书写先后顺序加载，而且只加载一次。
?3:成员变量和非静态代码块根据书写先后顺序加载。

public class LoadOrder {
    public static void main(String[] args) {

//        System.out.println("------调用子类静态变量⬇-------");
//        //子类静态变量
//        A a1 = C.a1;
//        System.out.println("------调用父类静态变量⬇-------");
//        //父类静态变量
//        A a = C.a;

        System.out.println("------实例化子类对象1⬇-------");
        //子类对象1
        C c1 = new C();
        System.out.println("------实例化子类对象2⬇-------");
        //子类对象2
        C c2 = new C();
    }
}
class F {
    //父类静态变量1
    static A a = new A("父类静态变量->1");

    //父类成员变量
    A a3 = new A("父类成员变量");

    //父类静态代码块1
    static {
        System.out.println("父类静态代码块->1");
    }
    //父类非静态代码块
    {
        System.out.println("父类非静态代码块");
    }
    //父类构造方法
    public F(){
        System.out.println("父类构造方法");
    }
    //父类静态变量2
    static A a2 = new A("父类静态变量->2");
    //父类静态代码块2
    static {
        System.out.println("父类静态代码块->2");
    }
}

class C extends F{

    //子类成员变量1
    A a3 = new A("子类成员变量->1");
    //子类静态代码块
    static {
        System.out.println("子类静态代码块");
    }
    //子类非静态代码块1
    {
        System.out.println("子类非静态代码块->1");
    }
    //子类成员变量2
    A a4 = new A("子类成员变量->2");
    //子类构造方法
    public C(){
        System.out.println("子类构造方法");
    }
    //子类非静态代码块2
    {
        System.out.println("子类非静态代码块->2");
    }
    //子类静态变量
    static A a1 = new A("子类静态变量");
}

class A{
    public A(String str){
        System.out.println(str);
    }
}

执行结果

------实例化子类对象1⬇-------
父类静态变量->1
父类静态代码块->1
父类静态变量->2
父类静态代码块->2
子类静态代码块
子类静态变量
父类成员变量
父类非静态代码块
父类构造方法
子类成员变量->1
子类非静态代码块->1
子类成员变量->2
子类非静态代码块->2
子类构造方法
------实例化子类对象2⬇-------
父类成员变量
父类非静态代码块
父类构造方法
子类成员变量->1
子类非静态代码块->1
子类成员变量->2
子类非静态代码块->2
子类构造方法

题 1

package Test;

public class LoadOrder2 {
    public static void main(String[] args) {
        F1 f = new C1();
    }
}

class F1 {

    public String str = "Father";

    public F1(){
        call();
    }

    public void call(){
        System.out.println("father----->"+str);
    }
}

class C1 extends F1{

    private String str = "Child";

    public C1(){
        call();
    }

    @Override
    public void call(){
        System.out.println("child----->"+str);
    }
}

执行结果：
child----->null
child----->Child

两次都是执行的子类的call方法，第一次由于是父类的构造方法调用到子类的call方法，子类还没有加载成员变量str，所以是null。