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

 1 package cn.com.zfc.lesson05.inherit01;
 2
 3 /**
 4 *
 5 * @title A
 6 * @describe 超级父类 A
 7 * @author 张富昌
 8 * @date 2017年4月3日下午5:59:17
 9 */
10 public class A {
11
12 　　//普通成员变量
13
14 　　private AA aa = new AA();
15
16 　　//静态成员变量
17 　　private static AAA aaa = new AAA();
18
19
20
21 　　// 静态代码块
22 　　static {
23 　　　　System.out.println("我是超级父类 A 的静态代码块");
24 　　}
25
26
27
28 　　// 普通代码块
29 　　{
30 　　　　System.out.println("我是超级父类 A 的普通代码块");
31 　　}
32
33
34
35 　　// 无参构造方法
36 　　public A() {
37 　　　　System.out.println("我是超级父类 A 的无参构造方法");
38 　　}
39 }

2、父类B

 1 package cn.com.zfc.lesson05.inherit01;
 2
 3 /**
 4 *
 5 * @title B
 6 * @describe 父类
 7 * @author 张富昌
 8 * @date 2017年4月3日下午5:59:17
 9 */
10 public class B extends A {
11
12 　　//普通成员变量
13 　　private BB bb = new BB();
14
15 　　//静态成员变量
16 　　private static BBB bbb = new BBB();
17
18
19
20 　　// 静态代码块
21 　　static {
22 　　　　System.out.println("我是父类 B 的静态代码块");
23 　　}
24
25
26
27 　　// 普通代码块
28 　　{
29 　　　　System.out.println("我是父类 B 的普通代码块");
30 　　}
31
32
33
34 　　// 无参构造方法
35 　　public B() {
36 　　　　System.out.println("我是父类 B 的无参构造方法");
37 　　}
38 }

3、子类C

 1 package cn.com.zfc.lesson05.inherit01;
 2
 3 /**
 4 *
 5 * @title C
 6 * @describe 子类 C
 7 * @author 张富昌
 8 * @date 2017年4月3日下午5:59:17
 9 */
10 public class C extends B {
11
12 　　//普通成员变量
13
14 　　private CC cc = new CC();
15
16 　　//静态成员变量
17 　　private static CCC ccc = new CCC();
18
19
20 　　// 静态代码块
21 　　static {
22 　　　　System.out.println("我是子类 C 的静态代码块");
23 　　}
24
25
26
27 　　// 普通代码块
28 　　{
29 　　System.out.println("我是子类 C 的普通代码块");
30 　　}
31
32
33
34 　　// 无参构造方法
35 　　public C() {
36 　　　　System.out.println("我是子类 C 的无参构造方法");
37 　　}
38 }

4、AA类

 1 package cn.com.zfc.lesson05.inherit01;
 2
 3 /**
 4 *
 5 * @title AA
 6 * @describe 超级父类 A 的普通成员变量 AA
 7 * @author 张富昌
 8 * @date 2017年4月3日下午5:59:17
 9 */
10 public class AA {
11 　　// 静态代码块
12 　　static {
13 　　　　System.out.println("我是超级父类 A 的普通成员变量 AA 的静态代码块");
14 　　}
15
16
17
18 　　// 普通代码块
19 　　{
20 　　　　System.out.println("我是超级父类 A 的普通成员变量 AA 的普通代码块");
21 　　}
22
23
24
25 　　// 无参构造方法
26 　　public AA() {
27 　　　　System.out.println("我是超级父类 A 的普通成员变量 AA 的无参构造方法");
28 　　}
29 }

5、AAA类

 1 package cn.com.zfc.lesson05.inherit01;
 2
 3 /**
 4 *
 5 * @title AAA
 6 * @describe 超级父类 A 的静态成员变量 AAA
 7 * @author 张富昌
 8 * @date 2017年4月3日下午5:59:17
 9 */
10 public class AAA {
11 　　// 静态代码块
12 　　static {
13 　　　　System.out.println("我是超级父类 A 的静态成员变量 AAA 的静态代码块");
14 　　}
15
16
17
18 　　// 普通代码块
19 　　{
20 　　　　System.out.println("我是超级父类 A 的静态成员变量 AAA 的普通代码块");
21 　　}
22
23
24
25 　　// 无参构造方法
26 　　public AAA() {
27 　　　　System.out.println("我是超级父类 A 的静态成员变量 AAA 的无参构造方法");
28 　　}
29 }

6、BB类

 1 package cn.com.zfc.lesson05.inherit01;
 2
 3 /**
 4 *
 5 * @title BB
 6 * @describe 父类 B 的普通成员变量 BB
 7 * @author 张富昌
 8 * @date 2017年4月3日下午5:59:17
 9 */
10 public class BB {
11 　　// 静态代码块
12 　　static {
13 　　　　System.out.println("我是父类 B 的普通成员变量 BB 的静态代码块");
14 　　}
15
16
17
18 　　// 普通代码块
19 　　{
20 　　　　System.out.println("我是父类 B 的普通成员变量 BB 的普通代码块");
21 　　}
22
23
24
25 　　// 无参构造方法
26 　　public BB() {
27 　　　　System.out.println("我是父类 B 的普通成员变量 BB 的无参构造方法");
28 　　}
29 }

7、BBB类

 1 package cn.com.zfc.lesson05.inherit01;
 2
 3 /**
 4 *
 5 * @title BBB
 6 * @describe 父类 B 的静态成员变量 BBB
 7 * @author 张富昌
 8 * @date 2017年4月3日下午5:59:17
 9 */
10 public class BBB {
11 　　// 静态代码块
12 　　static {
13 　　　　System.out.println("我是父类 B 的静态成员变量 BBB 的静态代码块");
14 　　}
15
16
17
18 　　// 普通代码块
19 　　{
20 　　　　System.out.println("我是父类 B 的静态成员变量 BBB 的普通代码块");
21 　　}
22
23
24
25 　　// 无参构造方法
26 　　public BBB() {
27 　　　　System.out.println("我是父类 B 的静态成员变量 BBB 的无参构造方法");
28 　　}
29 }

8、CC类

 1 package cn.com.zfc.lesson05.inherit01;
 2
 3 /**
 4 *
 5 * @title CC
 6 * @describe 子类 C 的普通成员变量 CC
 7 * @author 张富昌
 8 * @date 2017年4月3日下午5:59:17
 9 */
10 public class CC {
11 　　// 静态代码块
12 　　static {
13 　　　　System.out.println("我是子类 C 的普通成员变量 CC 的静态代码块");
14 　　}
15
16
17
18 　　// 普通代码块
19 　　{
20 　　　　System.out.println("我是子类 C 的普通成员变量 CC 的普通代码块");
21 　　}
22
23
24
25 　　// 无参构造方法
26 　　public CC() {
27 　　　　System.out.println("我是子类 C 的普通成员变量 CC 的无参构造方法");
28 　　}
29 }

9、CCC类

 1 package cn.com.zfc.lesson05.inherit01;
 2
 3 /**
 4 *
 5 * @title CCC
 6 * @describe 子类 C 的静态成员变量 CCC
 7 * @author 张富昌
 8 * @date 2017年4月3日下午5:59:17
 9 */
10 public class CCC {
11 　　// 静态代码块
12 　　static {
13 　　　　System.out.println("我是子类 C 的静态成员变量 CCC 的静态代码块");
14 　　}
15
16
17
18 　　// 普通代码块
19 　　{
20 　　　　System.out.println("我是子类 C 的静态成员变量 CCC 的普通代码块");
21 　　}
22
23
24
25 　　// 无参构造方法
26 　　public CCC() {
27 　　　　System.out.println("我是子类 C 的静态成员变量 CCC 的无参构造方法");
28 　　}
29 }

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

 1 package cn.com.zfc.lesson05.inherit01;
 2 /**
 3 *
 4 * @title TestC
 5 * @describe 测试子类C的创建过程
 6 * @author 张富昌
 7 * @date 2017年4月3日下午6:49:50
 8 */
 9 public class TestC {
10 　　public static void main(String[] args) {
11
12 　　　　//创建 C 对象
13 　　　　C c = new C();
14 　　}
15 }

三、测试结果

我是超级父类 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 的无参构造方法

总结：

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

转载于:https://www.cnblogs.com/zfc-java/p/6662416.html

Java 的类加载顺序相关推荐

关于 Java 同名类加载顺序问题排查方案
排查背景最近在生产上部署 UDF 时,遇到一个两个环境完全相同,但是一个客户端报错另一个正常的情况,经过多次调试问题终于得以解决,现将解决思路记录一下,希望能对后来者有所帮助.(生产环境不便于截图. ...
java包引入顺序_多个相同jar存在时的引用顺序
起因:今天一个aar包在测试环境中正常运行,使用soapui测试正常返回,在本地环境中运行则老是报数据库连接异常,经检查,是因为在运行时环境中缺少ojdbc相关的jar包引起的. 重新打了一个aar包 ...
JAVA基础--final、static区别以及类加载顺序
一.JAVA中final 与 static 总结 final static 修饰类该类不可被继承只能修饰内部类,该类不需要new,是静态加载(嵌套顶层类) 修饰接口 × × 修饰构造函数 × × ...
Java类的加载及父类子类加载顺序
点击 Mr.绵羊的知识星球解锁更多优质文章. 目录一.类的加载 1. 类加载 2. 类加载器二.父类和子类加载顺序 1. 案例(代码) 一.类的加载 1. 类加载当程序要使用某些类时,如果该类 ...
java中parent结构_详解java中继承关系类加载顺序问题
详解java中继承关系类加载顺序问题实例代码: /** * Created by fei on 2017/5/31. */ public class SonClass extends ParentC ...
JAVA静态内部类加载顺序
今天偶然机会碰到了JAVA的静态内部类加载实例,原本以为和外部类一样,但实验结果确出人意料,特此记录.希望大牛们能指出原因所在. 首先给上代码: public class LoadTest2 {pub ...
Java 类加载顺序与成员变量初始化
类加载顺序父类静态代码块(包括静态初始化块,静态属性,但不包括静态方法) 子类静态代码块(包括静态初始化块,静态属性,但不包括静态方法 ) 父类非静态代码块( 包括非静态初始化块,非静态属性 ) 父 ...
Java类加载顺序之一条日志引发的血案
目录为什么是null 回顾类加载原因问题重现总结类加载顺序子类重写被父类构造函数调用的函数注意不能放过不起眼的日志一条日志引发的案子 [11:12:58.505][D][Gen][RT ...
Java的类加载机制
jvm系列垃圾回收基础 JVM的编译策略 GC的三大基础算法 GC的三大高级算法 GC策略的评价指标 JVM信息查看 GC通用日志解读 jvm的card table数据结构 Java类初始化顺序 J ...

Java 的类加载顺序

Java 的类加载顺序相关推荐

最新文章

热门文章