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 的无参构造方法

总结：

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