java 类的加载总结

java类的加载顺序：

有继承时：

1.按代码顺序递归加载静态成员/代码块，先父类再本类.。

2.按代码顺序递归加载非静态成员/代码块/调用构造函数，先父类再本类。.（注意同类中成员或代码块优于构造函数）

注意：父类构造方法中用到的方法如果已被子类重写，那么在构造子类对象时在调用父类构造函数中使用子类重写的方法

无继承时：

1.按代码顺序递归加载静态成员/代码块。

2.按代码顺序递归加载非静态成员/代码块。

3.按代码顺序递归调用构造函数。

java类的加载事项：1.调用静态成员时，加载静态成员所在的类及父类.

                                2.第一次new对象时加载（第二次new不再加载）

                                3.加载子类会先加载父类.有static和final修饰的成员不会被加载，当成常量使用.

//代码示例：
class A {
     public static int a = 10;
     public int b = 20;
     static {
          System.out.println("A 中静态代码块  ：" + a);
     }

     public A() {
          System.out.println("A 中空参构造函数  ： " + this.b);
     }

}

class B extends A {
     // 静态变量、静态块执行顺序，按书写先后顺序
     public static int a1 = getSuperStaticNumber();
     public int b1 = getSuperInstanceNumber();

     public B() {
          System.out.println("B 中空参构造函数 ：" + this.b1);
     }

     static {
          System.out.println("B 中静态代码块 ：" + a1);
     }

     public static int getSuperStaticNumber() {
          System.out.println("B 中静态方法 ");
         return 100;
     }

     public int getSuperInstanceNumber() {
          System.out.println("B 中非静态方法 ");
          return 200;
     }
}

public class C extends B {
     public static int a2 = getStaticNumber();
     public int b2 = getInstanceNumber();

     public C() {
          System.out.println("C 中空参构造函数 ：" + this.b2);
     }

     public static int getStaticNumber() {
          System.out.println("C 中静态方法 ");
          return 1000;
     }

     public int getInstanceNumber() {
          System.out.println("C 中非静态方法 ");
          return 2000;
     }

     static {
          System.out.println("C 中静态代码块 ：" + a2);
     }

     public static void main(String args[]) {
          new C();
     }
}
/*
结果为：
-------------------
A 中静态代码块  ：10
B 中静态方法
B 中静态代码块 ：100
C 中静态方法
C 中静态代码块 ：1000
A 中空参构造函数  ： 20
B 中非静态方法
B 中空参构造函数 ：200
C 中非静态方法
C 中空参构造函数 ：2000
-------------------
*/