Java中，子类父类中代码的加载顺序

最新推荐文章于 2023-01-12 22:41:26 发布
最新推荐文章于 2023-01-12 22:41:26 发布
阅读量233 收藏
点赞数
分类专栏： Java基础 开发 文章标签： Java加载顺序 父类子类加载
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/abreo/article/details/100532511
版权

本文主要通过代码的实现，来研究下载Java中，继承的时候，父类和子类中代码的加载顺序。

一，无继承的时候：

 首先我们先写几个类，其中类ClassA作为测试主体。

// 1,对象类，测试主体
public class ClassA {
//	public static  ClassA classa = new ClassA();
		
	static{
        System.out.println("ClassA的静态代码块A");
    }
	
	{
        System.out.println("ClassA的构造代码块A");
    }
	
    public ClassA_Public_A classA_Public_A = new ClassA_Public_A();
    
    private ClassA_Private_A classA_Private_A = new ClassA_Private_A();
    
	public static  ClassA_Static_A classA_Static_A = new ClassA_Static_A();
    
	static public void methodA(){
        System.out.println("ClassA的静态方法A");
    }
	
	
	static{
        System.out.println("ClassA的静态代码块B");
    }
	
	{
        System.out.println("ClassA的构造代码块B");
    }
    
	public ClassA_Public_B classA_Public_B = new ClassA_Public_B();
	    
    private ClassA_Private_B classA_Private_B = new ClassA_Private_B();
    
	public static  ClassA_Static_B classA_Static_B = new ClassA_Static_B();
    
	static public void methodB(){
        System.out.println("ClassA的静态方法B");
    }
    
    public ClassA(){
        System.out.println("ClassA的构造方法");
    }
    
    public void excuteOveride(){
        System.out.println("ClassA执行方法excuteOveride");
    }
}

//2,作为私有变量使用
public class ClassA_Private_A {
	
	public ClassA_Private_A(){
        System.out.println("ClassA_Private私有变量A");
    }

}

//3,作为私有变量使用
public class ClassA_Private_B {
	
	public ClassA_Private_B(){
        System.out.println("ClassA_Private私有变量B");
    }

}

//4,作为公有变量使用
public class ClassA_Public_A {
	
	public ClassA_Public_A(){
        System.out.println("ClassA_Public公有变量A");
    }

}

//5,作为公有变量使用
public class ClassA_Public_B {
	
	public ClassA_Public_B(){
        System.out.println("ClassA_Public公有变量B");
    }

}

// 6,作为静态变量使用
public class ClassA_Static_A {
	
	public ClassA_Static_A(){
        System.out.println("ClassA_Static静态变量A");
    }

}

// 7,作为静态变量使用
public class ClassA_Static_B {
	
	public ClassA_Static_B(){
        System.out.println("ClassA_Static静态变量B");
    }

}


//8,测试入口类
public class ClassTest {
	
	static {
        System.out.println("Test的静态代码块");
    }
	
	{
        System.out.println("Test构造代码块");
    }
	
	public ClassTest(){
        System.out.println("Test无参构造方法");
    }
	
    public ClassTest(String name){
        System.out.println("Test构造方法"+ name);
    }

    
    public static void main(String[] args) {
        System.out.println("ClassTest执行main方法");
        ClassA a = new ClassA();
        a.excuteOveride();
    }
    
    private static void testMethod(){
    	System.out.println("ClassTest执行testMethod方法");
    }
    
}

我们执行一下ClassTest类，执行结果如下：

--------------------------------------------------------

Test的静态代码块
ClassTest执行main方法
ClassA的静态代码块A
ClassA_Static静态变量A
ClassA的静态代码块B
ClassA_Static静态变量B
ClassA的构造代码块A
ClassA_Public公有变量A
ClassA_Private私有变量A
ClassA的构造代码块B
ClassA_Public公有变量B
ClassA_Private私有变量B
ClassA的构造方法
ClassA执行方法excuteOveride

--------------------------------------------------------

可以看到，无继承情况，在加载class时候，大原则是：

 1，先执行静态代码，

 2，其次执行普通代码，

 3，然后才是构造函数。

再细划分，每一部分都是按照代码在类中出现的顺序进行先后执行的。

 

二，有继承的时候：

我们再添加几个类，其中，ClassB作为测试主体：

// 子类ClassB，继承ClassA，测试主体
public class ClassB extends ClassA {
	
	static public void methodA(){
        System.out.println("ClassB的静态方法A");
    }
	
	static{
        System.out.println("ClassB的静态代码块A");
    }
	
	{
        System.out.println("ClassB的构造代码块A");
    }
	
	public static  ClassB_Static_A classB_Static_A = new ClassB_Static_A();
	
    private ClassB_Private_A classB_Private_A = new ClassB_Private_A();
    
    public ClassB_Public_A classB_Public_A = new ClassB_Public_A();
    
    public ClassB(){
        System.out.println("ClassB的构造方法");
    }
	
    static{
        System.out.println("ClassB的静态代码块B");
    }
	
	{
        System.out.println("ClassB的构造代码块B");
    }
	
	public static  ClassB_Static_B classB_Static_B = new ClassB_Static_B();
	
    private ClassB_Private_B classB_Private_B = new ClassB_Private_B();
    
    public ClassB_Public_B classB_Public_B = new ClassB_Public_B();
    
   
    public void excute(){
        System.out.println("ClassB执行方法excute");
    }
    
    public void excuteOveride(){
        System.out.println("ClassB执行方法excuteOveride");
    }
    
    static public void methodB(){
        System.out.println("ClassB的静态方法B");
    }
}

// 2 作为私有变量使用
public class ClassB_Private_A {
	
	public ClassB_Private_A(){
		System.out.println("ClassB_Private私有变量A");
    }

}
// 3 作为私有变量使用
public class ClassB_Private_B {
	
	public ClassB_Private_B(){
		System.out.println("ClassB_Private私有变量B");
    }

}
// 4 作为公有变量使用
public class ClassB_Public_A {
	
	public ClassB_Public_A(){
		System.out.println("ClassB_Public公有变量A");
    }

}

// 5 作为公有变量使用
public class ClassB_Public_B {
	
	public ClassB_Public_B(){
		System.out.println("ClassB_Public公有变量B");
    }

}
// 6 作为静态变量使用
public class ClassB_Static_A {
	
	public ClassB_Static_A(){
		System.out.println("ClassB_Static静态变量A");
    }

}

// 7 作为静态变量使用
public class ClassB_Static_B {
	
	public ClassB_Static_B(){
		System.out.println("ClassB_Static静态变量B");
    }

}

package com.oda.ai.controller.test;

// 8 测试入口类
public class ClassTest {
	
	static {
        System.out.println("Test的静态代码块");
    }
	
	{
        System.out.println("Test构造代码块");
    }
	
	public ClassTest(){
        System.out.println("Test无参构造方法");
    }
	
    public ClassTest(String name){
        System.out.println("Test构造方法"+ name);
    }

    
    public static void main(String[] args) {
        System.out.println("ClassTest执行main方法");
        ClassB b = new ClassB();
        b.excute();
        b.excuteOveride();
    }
    
    private static void testMethod(){
    	System.out.println("ClassTest执行testMethod方法");
    }
    
    
}

我们执行一下ClassTest类，执行结果如下：

--------------------------------------------------------

Test的静态代码块
ClassTest执行main方法
ClassA的静态代码块A
ClassA_Static静态变量A
ClassA的静态代码块B
ClassA_Static静态变量B
ClassB的静态代码块A
ClassB_Static静态变量A
ClassB的静态代码块B
ClassB_Static静态变量B
ClassA的构造代码块A
ClassA_Public公有变量A
ClassA_Private私有变量A
ClassA的构造代码块B
ClassA_Public公有变量B
ClassA_Private私有变量B
ClassA的构造方法
ClassB的构造代码块A
ClassB_Private私有变量A
ClassB_Public公有变量A
ClassB的构造代码块B
ClassB_Private私有变量B
ClassB_Public公有变量B
ClassB的构造方法
ClassB执行方法excute
ClassB执行方法excuteOveride

--------------------------------------------------------

可以看到，有继承情况，在加载class时候，大原则如下:

 1，先执行父类静态代码。

 2，其次执行子类静态代码。

 3，再次是父类普通代码。

 4，父类构造函数。

 5，之后是子类普通代码。

 6，最后子类构造函数。

同样，再细划分，每一部分都是按照代码在类中出现的顺序进行先后执行的。

同一部分中无论是变量还是代码块，都是按照代码出现在类中的先后顺序执行。

 

三，最后我们修改下测试入口类如下：

    即不创建对象实例，直接调用类的静态方法：   

//测试入口类
public class ClassTest {
	
	static {
        System.out.println("Test的静态代码块");
    }
	
	{
        System.out.println("Test构造代码块");
    }
	
	public ClassTest(){
        System.out.println("Test无参构造方法");
    }
	
    public ClassTest(String name){
        System.out.println("Test构造方法"+ name);
    }

    
    public static void main(String[] args) {

        System.out.println("ClassTest执行main方法");
        
        ClassB.methodB();
        
    }
    
    private static void testMethod(){
    	System.out.println("ClassTest执行testMethod方法");
    }
    
}

执行结果如下

--------------------------------------------------------

Test的静态代码块
ClassTest执行main方法
ClassA的静态代码块A
ClassA_Static静态变量A
ClassA的静态代码块B
ClassA_Static静态变量B
ClassB的静态代码块A
ClassB_Static静态变量A
ClassB的静态代码块B
ClassB_Static静态变量B
ClassB的静态方法B
--------------------------------------------------------

可以看到，再不创建实例的情况下，直接调用类的静态方法，

只是加载父类静态代码，和子类静态代码。

 

 

 

abreo
关注
专栏目录
Java中父类和子类的加载和执行顺序解析
DevAstro的博客
09-28 272
在Java中，父类和子类的加载和执行顺序是先加载父类，然后加载子类。创建子类对象时，先分配内存空间，然后按照父类优先的顺序初始化父类的实例变量和调用父类的构造方法，最后初始化子类的实例变量和调用子类的构造方法。在Java中，当使用继承关系创建父类和子类时，会涉及到父类和子类的加载和执行顺序。下面我将详细解析父类和子类的加载和执行顺序，并提供相应的源代码来说明。在Java中，当我们创建一个子类对象时，首先会加载父类，然后再加载子类。当父类和子类都加载完毕后，就可以创建子类对象了。接下来，会加载子类。
Java父类、子类以及内部类加载顺序
Gloay的博客
02-01 1478
1.Java类内部加载顺序 首先我们看一个类内部变量的加载顺序： Java的类在Java编译器中，一个基本规则是按照变量定义的顺序来觉得初始化顺序，但对于静态变量和构造方法有些特殊的规则，如下： 静态代码块，在类被加载的时候运行，因此只加载一次，且优先于其他变量，常用于运行一些项目启动时需要运行的代码，比如加载项目需要的系统资源等等。 示例： static{ System.out.pri...
浅谈Java中父类与子类的加载顺序详解
09-05
本篇文章是对Java中父类与子类的加载顺序进行了详细的分析介绍，需要的朋友参考下
子类父类加载顺序
TheChooseOne的博客
11-20 710
1.创建第一个子类对象时： 父类静态块->被调子类静态块->父类动态块->父类无参构造器->被调子类动态块->被调子类无参构造器 2.创建第一个另一子类对象时： 被调子类静态块->父类动态块->父类无参构造器->被调子类动态块->被调子类无参构造器 注意：1.父类静态块只会被调用一次。           2.这里是“另一子类”，就是...
子父类加载顺序
weixin_43266984的博客
05-18 1932
1、首先加载的是父类静态变量，加载父类的静态代码块（一个类中多个静态代码块，按顺序加载） 2、加载子类静态变量，加载子类的静态代码块（一个类中多个静态代码块，按顺序加载） 3、加载父类非静态代码块 4、默认加载父类的无参构造（没有无参构造的话，需要在子类的构造方法第一行写super(参数）) 5、加载子类的构造方法， 6、如果子类没有覆盖父类的方法，执行的时候是执行的是父类的方法 package text4; /** * 子类加载父类时候 * @author z2424 */ public clas
有父类的类加载顺序
blog
06-11 828
下面代码的输出是什么？1234567891011121314151617181920212223242526public class Base{    private String baseName = "base";    public Base()    {        callName();    }     public void callName()    {        Syste...
父类和子类加载顺序
qq_29401881的博客
06-30 565
/** * @author: zhangweiqiang * @date: 2021/6/30 9:12 */ public class Father { public Father() { System.out.println(Son.F); } static { System.out.println(Son.F); } } class Son extends Father { public static String F
实例解析JAVA中代码的加载顺序
08-30
Java中代码的加载顺序实例解析 Java是一种面向对象的编程语言，了解Java中代码的加载顺序是非常重要的。下面我们将通过实例解析Java中代码的加载顺序，详细介绍Java中代码块的执行顺序。 类的依赖关系 在Java中，...
java 代码块与静态代码块加载顺序
08-29
Java 代码块与静态代码块加载顺序是 Java 语言中一个重要的概念，理解这两个概念对于编写高效、可靠的 Java 代码至关重要。本文将详细介绍 Java 代码块与静态代码块加载顺序的相关知识点，并提供实例代码来帮助读者...
子类继承父类的加载顺序详解
养只狗名叫猫
01-09 3108
题记：以前总是对不会的东西逃避，但是不会早晚有一天还是会找到你，今天以此笔记做记！ 分析两种情况的加载顺序，一种：单独类的加载顺序。二：子类继承父类的加载顺序 一：单独类的加载顺序 静态变量、静态代码块（从上到下的顺序加载） 类的非静态变量，非静态块（从上到下的顺序加载） 构造函数 二：子类继承父类的加载顺序 父类静态变量、父类静态代码块（从上到下的顺序加载） 子类静态变量、子类静态...
子类继承父类的加载顺序——记录篇
weixin_44648502的博客
08-20 582
两种情况的加载顺序： 初始化阶段的初始化步骤： 静态代码块(先父类后子类)—-------->(非静态代码块-------**>**父类)—先父类后子类 一、单独类的加载顺序 静态变量、静态代码块：从上到下的顺序加载。 类的非静态变量，非静态块：从上到下的顺序加载。 构造函数。 二、子类继承父类的加载顺序 父类静态变量、父类静态代码块(从上到下的顺序加载) 子类静态变量、子类静态代码块(从上到下的顺序加载) 父类的非静态变量、父类的非静态代码块(从上到下的顺序加载) 父类的构造方法。 子类的非静
Java中父类与子类的加载顺序
04-23 1074
class Parent { // 静态变量 public static String p_StaticField = "父类--静态变量"; // 变量(其实这用对象更好能体同这一点，如专门写一个类的实例) 　　 //如果这个变量放在初始化块的后面，是会报错的，因为你根本没有被初始化 public String p_Field = "父类--变量";
Java中 子、父类加载的顺序问题
斗胆潇洒~★
10-19 1960
Java中子父类加载的顺序问题 在论坛看到这么个问题，经过一番分析，应该是子父类加载顺序导致的问题： 别人的问题： class Base { public Base() { test(); } public void test() //①号test方法
Java继承中父类和子类的加载顺序
weixin_30352645的博客
07-07 745
前两天写东西，本来想把定义和实现分开来写的。类A有两个方法f1和f2，想把类A的定义、f1的实现和f2的实现分为三个java文件来写，看了看抽象类和接口。不过貌似都不是搞这个的样子。（求方法） 总结一下，自己看的继承和接口。 继承 Java中很基本的概念。如书所言： （1）java不支持多重继承，也就是说子类至多只能有一个父类 （2）子类继承了其父类中...
子类与父类之间的加载顺序
qq_42177755的博客
08-26 318
（1） 静态方法 （2）父类静态代码块（静态初始化块，静态属性，但不包括静态方法） （3）子类静态代码块（静态初始化块，静态属性，但不包括静态方法） （4） 父类非静态代码块（ 包括非静态初始化块，非静态属性） （5）父类构造函数 （6）子类非静态代码块（ 包括非静态初始化块，非静态属性） （7） 子类构造函数 public class Father { static { System.out.println("Father中的静态块:1"); } static { System.ou
Java类的加载及父类子类加载顺序
Mr.绵羊的知识星球
01-12 3277
1. 类加载和类加载器介绍 2. 父类和子类加载顺序及实际案例 3. 子类父类加载顺序面试
java 父类加载的顺序_Java 父类子类加载顺序
weixin_35078549的博客
02-25 300
1.父类静态代码块 ( java虚拟机加载类时，就会执行该块代码，故只执行一次)2 .子类静态代码块 ( java虚拟机加载类时，就会执行该块代码，故只执行一次)3. 父类属性对象初始化4.父类普通代码块(每次new,每次执行 )5. 父类构造函数(每次new,每次执行)6.子 类 属性对象初始化7.子类普通代码块(每次new,每次执行 )8.子 类构造函数(每次new,每次执行)9.子类重写...
Java 父类子类加载顺序
qq_22028771的博客
08-03 320
1.父类静态代码块 （ java虚拟机加载类时，就会执行该块代码，故只执行一次） 2 .子类静态代码块（ java虚拟机加载类时，就会执行该块代码，故只执行一次） 3.父类属性对象初始化 4.父类普通代码块（每次new,每次执行） 5.父类构造函数（每次new,每次执行） 6.子类属性对象初始化 7.子类普通代码块（每次new,每次执行） 8.子类构造函数（每次n...
父类子类显示初始化和构造方法的加载顺序
最新发布
03-26
在Java中，父类子类的对象初始...总结起来，父类子类显示初始化和构造方法的加载顺序是：父类静态初始化块->子类静态初始化块->父类实例变量和实例初始化块->父类构造方法->子类实例变量和实例初始化块->子类构造方法。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值