Java 的类加载顺序

 

Java 的类加载顺序

一、加载顺序：先父类后子类，先静态后普通

1、父类的静态成员变量初始化

2、父类的静态代码块

3、子类的静态成员变量初始化

4、子类的静态代码块

5、父类的普通成员变量初始化

6、父类的普通代码块

7、父类的无参构造器

8、子类的普通成员变量

9、子类的普通代码块

10、子类的无参构造器

二、示例代码

　　超级父类A，父类B，子类C，B继承A，C继承B；

　　AA、AAA、BB、BBB、CC、CCC都有各自的普通、静态成员变量，普通、静态代码块和无参构造器

　　超级父类A的普通成员变量aa（AA类的实例），超级父类A的静态成员变量aaa（AAA类的实例）；

　　父类B的普通成员变量bb（BB类的实例），父类B的静态成员变量bbb（BBB类的实例）；

　　子类C的普通成员变量cc（CC类的实例），子类C的静态成员变量ccc（CCC类的实例）；

1、超级父类A

package cn.com.zfc.lesson05.inherit01;

/**
* 
* @title A
* @describe 超级父类 A
* @author 张富昌
* @date 2017年4月3日下午5:59:17
*/
public class A {

　　//普通成员变量

　　private AA aa = new AA();

　　//静态成员变量
　　private static AAA aaa = new AAA();

 

　　// 静态代码块
　　static {
　　　　System.out.println("我是超级父类 A 的静态代码块");
　　}

 

　　// 普通代码块
　　{
　　　　System.out.println("我是超级父类 A 的普通代码块");
　　}

 

　　// 无参构造方法
　　public A() {
　　　　System.out.println("我是超级父类 A 的无参构造方法");
　　}
}

2、父类B

package cn.com.zfc.lesson05.inherit01;

/**
* 
* @title B
* @describe 父类
* @author 张富昌
* @date 2017年4月3日下午5:59:17
*/
public class B extends A {

　　//普通成员变量
　　private BB bb = new BB();

　　//静态成员变量
　　private static BBB bbb = new BBB();

 

　　// 静态代码块
　　static {
　　　　System.out.println("我是父类 B 的静态代码块");
　　}

 

　　// 普通代码块
　　{
　　　　System.out.println("我是父类 B 的普通代码块");
　　}

 

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

3、子类C

package cn.com.zfc.lesson05.inherit01;

/**
* 
* @title C
* @describe 子类 C
* @author 张富昌
* @date 2017年4月3日下午5:59:17
*/
public class C extends B {

　　//普通成员变量

　　private CC cc = new CC();

　　//静态成员变量
　　private static CCC ccc = new CCC();


　　// 静态代码块
　　static {
　　　　System.out.println("我是子类 C 的静态代码块");
　　}

 

　　// 普通代码块
　　{
　　System.out.println("我是子类 C 的普通代码块");
　　}

 

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

4、AA类

package cn.com.zfc.lesson05.inherit01;

/**
* 
* @title AA
* @describe 超级父类 A 的普通成员变量 AA
* @author 张富昌
* @date 2017年4月3日下午5:59:17
*/
public class AA {
　　// 静态代码块
　　static {
　　　　System.out.println("我是超级父类 A 的普通成员变量 AA 的静态代码块");
　　}

 

　　// 普通代码块
　　{
　　　　System.out.println("我是超级父类 A 的普通成员变量 AA 的普通代码块");
　　}

 

　　// 无参构造方法
　　public AA() {
　　　　System.out.println("我是超级父类 A 的普通成员变量 AA 的无参构造方法");
　　}
}

5、AAA类

package cn.com.zfc.lesson05.inherit01;

/**
* 
* @title AAA
* @describe 超级父类 A 的静态成员变量 AAA
* @author 张富昌
* @date 2017年4月3日下午5:59:17
*/
public class AAA {
　　// 静态代码块
　　static {
　　　　System.out.println("我是超级父类 A 的静态成员变量 AAA 的静态代码块");
　　}

 

　　// 普通代码块
　　{
　　　　System.out.println("我是超级父类 A 的静态成员变量 AAA 的普通代码块");
　　}

 

　　// 无参构造方法
　　public AAA() {
　　　　System.out.println("我是超级父类 A 的静态成员变量 AAA 的无参构造方法");
　　}
}

6、BB类 

package cn.com.zfc.lesson05.inherit01; 

/**
* 
* @title BB
* @describe 父类 B 的普通成员变量 BB
* @author 张富昌
* @date 2017年4月3日下午5:59:17
*/
public class BB {
　　// 静态代码块
　　static {
　　　　System.out.println("我是父类 B 的普通成员变量 BB 的静态代码块");
　　}

 

　　// 普通代码块
　　{
　　　　System.out.println("我是父类 B 的普通成员变量 BB 的普通代码块");
　　}

 

　　// 无参构造方法
　　public BB() {
　　　　System.out.println("我是父类 B 的普通成员变量 BB 的无参构造方法");
　　}
}

7、BBB类

package cn.com.zfc.lesson05.inherit01;

/**
* 
* @title BBB
* @describe 父类 B 的静态成员变量 BBB
* @author 张富昌
* @date 2017年4月3日下午5:59:17
*/
public class BBB {
　　// 静态代码块
　　static {
　　　　System.out.println("我是父类 B 的静态成员变量 BBB 的静态代码块");
　　}

 

　　// 普通代码块
　　{
　　　　System.out.println("我是父类 B 的静态成员变量 BBB 的普通代码块");
　　}

 

　　// 无参构造方法
　　public BBB() {
　　　　System.out.println("我是父类 B 的静态成员变量 BBB 的无参构造方法");
　　}
}

8、CC类 

package cn.com.zfc.lesson05.inherit01;

/**
* 
* @title CC
* @describe 子类 C 的普通成员变量 CC
* @author 张富昌
* @date 2017年4月3日下午5:59:17
*/
public class CC {
　　// 静态代码块
　　static {
　　　　System.out.println("我是子类 C 的普通成员变量 CC 的静态代码块");
　　}

 

　　// 普通代码块
　　{
　　　　System.out.println("我是子类 C 的普通成员变量 CC 的普通代码块");
　　}

 

　　// 无参构造方法
　　public CC() {
　　　　System.out.println("我是子类 C 的普通成员变量 CC 的无参构造方法");
　　}
}

9、CCC类

package cn.com.zfc.lesson05.inherit01;

/**
* 
* @title CCC
* @describe 子类 C 的静态成员变量 CCC
* @author 张富昌
* @date 2017年4月3日下午5:59:17
*/
public class CCC {
　　// 静态代码块
　　static {
　　　　System.out.println("我是子类 C 的静态成员变量 CCC 的静态代码块");
　　}

 

　　// 普通代码块
　　{
　　　　System.out.println("我是子类 C 的静态成员变量 CCC 的普通代码块");
　　}

 

　　// 无参构造方法
　　public CCC() {
　　　　System.out.println("我是子类 C 的静态成员变量 CCC 的无参构造方法");
　　}
}

10、测试子类C的创建过程：TestC.java

package cn.com.zfc.lesson05.inherit01;
/**
* 
* @title TestC
* @describe 测试子类C的创建过程
* @author 张富昌
* @date 2017年4月3日下午6:49:50
*/
public class TestC {
　　public static void main(String[] args) {

　　　　//创建 C 对象
　　　　C c = new C();
　　}
}

三、测试结果

我是超级父类 A 的静态成员变量 AAA 的静态代码块
我是超级父类 A 的静态成员变量 AAA 的普通代码块
我是超级父类 A 的静态成员变量 AAA 的无参构造方法
我是超级父类 A 的静态代码块
我是父类 B 的静态成员变量 BBB 的静态代码块
我是父类 B 的静态成员变量 BBB 的普通代码块
我是父类 B 的静态成员变量 BBB 的无参构造方法
我是父类 B 的静态代码块
我是子类 C 的静态成员变量 CCC 的静态代码块
我是子类 C 的静态成员变量 CCC 的普通代码块
我是子类 C 的静态成员变量 CCC 的无参构造方法
我是子类 C 的静态代码块
我是超级父类 A 的普通成员变量 AA 的静态代码块
我是超级父类 A 的普通成员变量 AA 的普通代码块
我是超级父类 A 的普通成员变量 AA 的无参构造方法
我是超级父类 A 的普通代码块
我是超级父类 A 的无参构造方法
我是父类 B 的普通成员变量 BB 的静态代码块
我是父类 B 的普通成员变量 BB 的普通代码块
我是父类 B 的普通成员变量 BB 的无参构造方法
我是父类 B 的普通代码块
我是父类 B 的无参构造方法
我是子类 C 的普通成员变量 CC 的静态代码块
我是子类 C 的普通成员变量 CC 的普通代码块
我是子类 C 的普通成员变量 CC 的无参构造方法
我是子类 C 的普通代码块
我是子类 C 的无参构造方法

总结：

　　第一点，所有的类都会优先加载基类
　　第二点，静态成员的初始化优先
　　第三点，成员初始化后，才会执行构造方法
　　第四点，静态成员的初始化与静态块的执行，发生在类加载的时候。
　　第四点，类对象的创建以及静态块的访问，都会触发类的加载。