代码混合执行顺序

最新推荐文章于 2026-04-20 03:15:15 发布
原创 最新推荐文章于 2026-04-20 03:15:15 发布 · 187 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文通过实例分析了Java和C#中代码的执行顺序，包括实例初始化、继承、this和super的使用、虚方法调用以及类初始化和实例初始化的混合情况。详细解释了在不同场景下，代码执行的逻辑，帮助理解这两门语言的运行机制。

阅读如下代码

class HelloA{
    public HelloA(){
        System.out.println("HelloA");
    }
    {
        System.out.println("I'm A Class");
    }
}
​
class HelloB extends HelloA{
    public HelloB(){
        //super(); // 调用父类构造函数（1）
        System.out.println("HelloB");
    }
    {
        System.out.println("I'm B Class");
    }
}
​
public class TestHelloB{
    public static void main(String[] args) {
        new HelloB();
    }
}
1、代码new的是HelloB  所以进入HelloB类 
                子类的所有构造方法中都有一个隐藏的父类构造函数super()
2、进入HelloB的无参构造中---->super()--->HelloA
实例初始化的顺序
        1>super()
        2>显式赋值
        3>普通成员代码块内容
        4>构造器内容
2和3的位置谁的顺序在前面就谁先执行，但是1和4的顺序是固定的
3、执行HelloA中的代码块---->无参构造----->回到子类
4、执行HelloB中的代码快----->无参构造----->返回main函数

I'm A Class
HelloA
I'm B Class
HelloB

阅读如下代码

public class TestFatherChild {
	public static void main(String[] args) {
		Father f = new Father();//（1）
		Child c = new Child();//（2）
	}
}
class Father {
	public Father(){
		System.out.println("father");
	}
}
class Child extends Father{
	public Child(){
		System.out.println("child");
	}
}
1、语句1进入father类的无参---->先输出fathe
2、语句2进入child类的无参----->有默认的super()---->去父类father
3、没有显式赋值和代码块  所以直接执行构造器内容---->输出father
4、回到child类---->同上  进入无参---->输出child

father
father
child

实例初始化运行结果分析

public class Test01 {
    public static void main(String[] args) {
        new Child("mike");
    }
}
​
class People {
    private String name;
​
    public People() {
        System.out.print("1");
    }
​
    public People(String name) {
        System.out.print("2");
        this.name = name;
    }
}
​
class Child extends People {
    People father;
​
    public Child(String name) {
        System.out.print("3");
        father = new People(name + " F");
    }
​
    public Child() {
        System.out.print("4");
    }
}
1、进入child类---->super（）---->进入People类无参
2、输出1---->回到child类----->
3、输出3----->new People  
4、进入Peoper有参---->输出2---->name =mikeF

答案：132

继承、属性同名问题

public class Test02 extends Father{
    private String name = "test";
    
    public static void main(String[] args) {
        Test02 test = new Test02();
        System.out.println(test.getName());
    }
}
class Father {
    private String name = "father";
​
    public String getName() {
        return name;
    }
}

1、进入Test02（）----->super()--->进入Father---->x显示赋值name = father------>没有代码块还有构造器内容  所以返回test02

2、name = test   test.getName();------>子类没有  所以去父类找----->这个方法是父类里的所以    name是父类的赋值所以是father

实例初始化

public class Test03 {
​
    public static void main(String[] args) {
        new A(new B());//（1）
    }
}
​
class A {
    public A() {
        System.out.println("A");
    }
​
    public A(B b) {
        this();
        System.out.println("AB");
    }
}
​
class B {
    public B() {
        System.out.println("B");
    }
}
1、（1）开始被混淆了
这样理解   B b = new B();
          A a = new A(b);
从里到外运行
所以显示运行B类  无参  ---->super()没有  所以回到main中
new A（）;----->有参数  所以是进入A（B b）---->this（）是调用A中的无参方法  所以输出A
----->再回到A（B b）中  输出AB
​

答案

B

A

AB

继承

public class Test04 {
    public static void main(String[] args) {
        Father f = new Father();
        Son s = new Son();
        System.out.println(f.getInfo());//1
        System.out.println(s.getInfo());//2
        s.setInfo("尚硅谷");//3
        System.out.println(f.getInfo());//4
        System.out.println(s.getInfo());//3
    }
}
class Father{
    private String info = "atguigu";
    public void setInfo(String info){
        this.info = info;
    }
    public String getInfo(){
        return info;
    }
}
class Son extends Father{
    
}

编译看左边 运行看右边

new 的是father所以  1>是atguigu

2>s.getInfo里面没有getInfo方法 所以去到父类   所以还是atguigu

3>s.setInfo已经在内存中赋值为尚硅谷  所以从s调用的get都变成了尚硅谷

4>f.getInfo还是atguigu没变

5>s.getInfo变成了尚硅谷

答案：

atguigu

atguigu

atguigu

尚硅谷

this和super

public class Test05{
    public static void main(String[] args) {
        Father f = new Father();
        Son s = new Son();
        System.out.println(f.getInfo());//1
        System.out.println(s.getInfo());//2
        s.test();//3
        System.out.println("-----------------");
        s.setInfo("大硅谷");//4
        System.out.println(f.getInfo());//5
        System.out.println(s.getInfo());//6
        s.test();
    }
}
class Father{
    private String info = "atguigu";
    public void setInfo(String info){
        this.info = info;
    }
    public String getInfo(){
        return info;
    }
}
class Son extends Father{
    private String info = "尚硅谷";
    public void test(){
        System.out.println(this.getInfo());
        System.out.println(super.getInfo());
    }
}

1>f.getInfo()-->去到father类调用getInfo ---->输出atguigu

2>s.getInfo()-->去到son类中调用geInfo  类中没有getInfo所以去父类--->父类有getInfo所以调用父类的  --->输出atguigu

3>s.test()  方法中有两个调用this.getInfo和super.getInfo  son类中没有所以去父类  所以两个输出都是atguigu

4>s.setInfo()，s是在内存中新建的一个空间 所以s的setInfo已经变成了“大硅谷”

5>f.getInfo()，没有改变所以还是atguigu

6>s.getInfo()，第四行已经改变了值所以调用s.getInfo是daguigu

7>s.test()，--->到达son中的test方法中当前类没有getInfo所以去父类   

但是s.setInfo已经被赋值了大硅谷  所以输出大硅谷

答案

atguigu
atguigu
atguigu
atguigu
-----------------
atguigu
大硅谷
大硅谷
大硅谷

第6题：this、super、重写

public class Test06 {
    public static void main(String[] args) {
        Father f = new Father();
        Son s = new Son();
        System.out.println(f.getInfo());//1
        System.out.println(s.getInfo());//2
        s.test();//3
        System.out.println("-----------------");
        s.setInfo("大硅谷");//4
        System.out.println(f.getInfo());//5
        System.out.println(s.getInfo());//6
        s.test();//7
    }
}
class Father{
    private String info = "atguigu";
    public void setInfo(String info){
        this.info = info;
    }
    public String getInfo(){
        return info;
    }
}
class Son extends Father{
    private String info = "尚硅谷";
    public void setInfo(String info){
        this.info = info;
    }
    public String getInfo(){
        return info;
    }
    public void test(){
        System.out.println(this.getInfo());
        System.out.println(super.getInfo());
    }
}

1>  atguigu

2>  尚硅谷

3>  尚硅谷     atguigu

4> 已经修改了s.setInfo()所以 s.getInfo是大硅谷

5> atguigu

6> 大硅谷

7> 大硅谷  atguigu

答案：

atguigu
尚硅谷
尚硅谷
atguigu
-----------------
atguigu
大硅谷
大硅谷
atguigu

    

第7题：this

public class Test07 {
    public static void main(String[] args) {
        Father f = new Son();//1
        System.out.println(f.x);//5
    }
}
class Father{
    int x = 10;
    public Father(){
        this.print();//2
        x = 20;
    }
    public void print(){
        System.out.println("Father.x = " + x);
    }
}
class Son extends Father{
    int x = 30;
    public Son(){
        this.print();//3
        x = 40;
    }
    public void print(){
        System.out.println("Son.x = " + x);//4
    }
}

1、第一行是多态  编译看左边  运行看右边   先看左边有啥方法  再看son有没有重写

1>调用son的无参  默认有一个super  所以去到父类  运行顺序  显式赋值  代码块  构造方法

  显示赋值是10  没有代码块  所以是运行构造器   运行第二  第二在son中已经被重写了  所以运行重写了的   跳到第四   代码又是就近原则   这里面x还没赋值所以第一行是son.x=0

2、输出完成之后进入显式赋值  x=30在进入构造方法  所以进入第三  第三跳入第四  所以再次输出son.x=30

3、实例初始化不干涉属性  所以最后f.x=20

第8题：虚方法

public class Test08 {
    public static void main(String[] args) {
        A a1 = new A();//1
        A a2 = new B();//2
        B b = new B();//3
        C c = new C();//4
        D d = new D();//5
        System.out.println("(1)" + a1.show(b));//6
        System.out.println("(2)" + a2.show(d));//7
        System.out.println("(3)" + b.show(c));//8
        System.out.println("(4)" + b.show(d));//9
    }
}
class A{
    public String show(D obj){
        return ("A and D");
    }
    public String show(A obj){
        return "A and A";
    }
}
class B extends A{
    public String show(B obj){
        return "B and B";
    }
    public String show(A obj){
        return "B and A";
    }
}
class C extends B{
    
}
class D extends B{
    
}
a1是A类型的    带入一个b   因为b是B类型的  因为A中没有B类型的方法  可以直接去找他的父类
4同下B类的show(d)先去B类中找找不到接收D类型的 那么向上找  A中也没有   那么就找能接受它的父类 所以是A and D
/*(1)A and A
(2)A and D
(3)B and B
(4)A and D*/

虚方法

public class Test09 {
    public static void main(String[] args) {
        A a1 = new A();//1
        A a2 = new B();//2
        B b = new B();//3
        C c = new C();//4
        D d = new D();//5
        System.out.println("(1)" + a1.show(b));//6
        System.out.println("(2)" + a2.show(d));//7
        System.out.println("(3)" + b.show(c));//8
        System.out.println("(4)" + b.show(d));//9
    }
}
​
class A {
    public String show(C obj) {
        return ("A and C");
    }
​
    public String show(A obj) {
        return "A and A";
    }
}
​
class B extends A {
    public String show(B obj) {
        return "B and B";
    }
​
    public String show(A obj) {
        return "B and A";
    }
}
​
class C extends B {
​
}
​
class D extends B {
​
}

第8   去b找show  b中没有接收C类型的方法  因为B继承了A子类没有就想上找 A有 所以输出

A and  C；

答案：

(1)A and A
(2)B and A
(3)A and C
(4)B and B

类初始化和实例初始化混合

public class Student extends Person {
    public int age = getAge();
    public int getAge() {
        System.out.println("Student getAge() 6");
        return 0;
    }
    static String country = getCountry();

    public static String getCountry() {
        System.out.println("Student getCountry() 7");
        return null;
    }
    static {
        System.out.println("Student 静态代码块 8 ");
    }
    {
        System.out.println("Student 普通代码块 9 ");
    }
    public Student() {
        System.out.println("Student 无参 A");
    }
}
class Student extends Person {
    public int age = getAge();
    public int getAge() {
        System.out.println("Student getAge() 6");
        return 0;
    }
    static String country = getCountry();

    public static String getCountry() {
        System.out.println("Student getCountry() 7");
        return null;
    }
    static {
        System.out.println("Student 静态代码块 8 ");
    }
    {
        System.out.println("Student 普通代码块 9 ");
    }
    public Student() {
        System.out.println("Student 无参 A");
    }
}

先父类后子类  先类初始化后实例初始化

父类 类初始化--->子类初始化--->父类实例初始化----->子类实例初始化（注意重写 如果子类有重写那么就不输出父类直接去子类）

答案：

Person getCountry()  2
Person 静态代码块  3
Student getCountry() 7
Student 静态代码块 8 
Student getAge() 6
Person 普通代码块 4
Person 无参 5
Student getAge() 6
Student 普通代码块 9 
Student 无参 A

标签
#java #c# #jvm
progrmming
关注
混合密码系统代码
03-30
混合密码系统代码混合密码系统代码混合密码系统代码混合密码系统代码混合密码系统代码
Vue.js前端的混合的生命周期钩子合并
AI架构全栈开发实战笔记
05-20 1007
本文旨在全面解析Vue.js框架中混合(Mixin)与组件生命周期钩子的合并机制。Vue.js混合系统的工作原理生命周期钩子的合并策略执行顺序的确定规则实际开发中的最佳实践本文适用于Vue 2.x和Vue 3.x版本，但会明确指出两个版本间的差异。首先介绍基本概念和背景知识然后深入分析合并机制的核心原理接着通过代码示例展示实际应用最后探讨高级主题和最佳实践混合(Mixin): Vue.js中一种分发可复用功能的灵活方式，可以包含任意组件选项生命周期钩子。
C#类的初始化顺序详解
listennerBGM的博客
02-18 5539
在主程序创建相关类时,看看类的各个成员的先后调用情况,首先说下没有继承其他类的情况: class Program { static void Main(string[] args) { TestClass1 testClass1=new TestClass1(); Console.Read(); } class TestClass1 { pub
eclipse如何多语言/代码混合编程
01-01 1091
eclipse如何多语言/代码混合调试方法。 1、混合java和c语言代码调试 Eclipse——混合调试java与C++代码（Linux下Debug） 2、 c和python混合代码调试 使用Nsight Eclipse调试py-faster-rcnn（C++/python混合代码调试） 这个没有用过。 3、 gnuradio中的p...
代码混合作战
weixin_30347009的博客
07-17 140
　　 如果有两个地方的团队A团队和B团队，当A团队开发了S平台，此时开发并未结束，公司急需要S平台在B团队来做演示和功能特性开发，那么，有两种做法来做版本控制。 第一种做法：开关变量控制 　　可以把B团队可以直接使用A团队的代码来开发特性功能，使用开关控制变量来进行两个个性版本的切换，两个特性版本具有相同的基础代码，那么相似的bug会在同一套代码当中修复。 第二种做法，拆分特性功能 　如果...
C C++代码混合使用
andy205214的专栏
06-11 1412
 传送门：http://developers.sun.com/solaris/articles/mixing.html#cpp_from_cThe C++ language provides mechanisms for mixing code that is compiled by compatible C and C++ compilers in the sam
构造函数初始化、static代码块初始化、成员变量初始化、以及在子父类中混合的执行顺序实例
exedllnet的专栏
07-01 315
以下代码： public class Son{Father father = new Father();static{System.out.println("Son static");}public Son(){System.out.println("Son()");}}public class Father {static{System.out.println("Father stat
mixins混合
Dear_Mr的博客
05-23 911
mixins混合混合是一种灵活的分布式复用 Vue 组件的方式。混合对象可以包含任意组件选项。以组件使用混合对象时，所有混合对象的选项将被混入该组件本身的选项。例子：// 定义一个混合对象 var myMixin = { created: function () { this.hello() }, methods: { hello: function () {
setInterval()和setTimeor()的混合应用
qq_41298974的博客
09-07 520
设置有两个悬浮按钮，分别控制两个setInterval定时器（myset1、myset2）的开启与关闭。其中，myset1的结构是先执行一个setTimeout，然后在这个setTimeout里再执行一个setTimeout。myset2的结构是先执行一个setTimeout，再执行一个setTimeout。
AES解密流程顺序搞反了？图解‘逆行移位’、‘逆字节替换’、‘轮密钥加’、‘逆列混合’的正确执行顺序
最新发布
weixin_30500105的博客
04-20 241
本文详细解析了AES解密流程的正确执行顺序，指出常见误区如逆行移位、逆字节替换、轮密钥加和逆列混合的错误排列。通过数学原理和代码示例，阐明解密步骤必须遵循特定顺序（逆行移位→逆字节替换→轮密钥加→逆列混合）才能正确还原数据，并对比了正确与错误顺序的解密结果差异。
Java初始化顺序
weixin_45826787的博客
05-11 208
Java初始化顺序 无继承普通类初始化顺序（同一优先级按语句先后顺序进行初始化） 1、静态属性、静态代码块 2、main方法 3、非静态属性、非静态代码块 4、构造方法（构造器） 有继承的类的初始化顺序 main方法在父类内时： 1、父类静态代码块 2、父类静态变量 3、main函数 4、子类静态代码块 5、子类静态变量 6、父类成员代码块 7、父类成员变量 8、父类构造器 9、子类代码块 10、子类成员变量 11、子类构造器 main方法在子类内时： 1、父类静态代码块 2、父类静态变量 3、子类静态代码
setTimeout、async、promise 混用的执行顺序
weixin_45678402的博客
05-06 488
setTimeout、async、promise 混用的执行顺序 async function async1() { console. log("2"); await async2(); console.log("7"); } async function async2() { console.log( '3'); } console.log("1"); setTimeout(function () { console. log("8"); }, 0); async1(); new Pr
异步函数顺序执行的实现
2byte
03-24 2212
这几天在研究实现一个类似Promise思想的库，也不完全一样，主要目标是保证异步事件的执行顺序。 比如有四个异步事件A,B,C,D 需要这样一个执行顺序 A => B => C => D 想了好几种方案。 其中有一种是先建立一个任务链表，执行时修改每个事件的函数内容。假设现在任务链表顺序已经建立， A => B => C => D。taskList[function A,function
C++的“执行顺序”谜题：警惕表达式中的未定义行为
weixin_42107409的博客
10-27 797
C++表达式中的未定义行为与求值顺序陷阱 本文深入探讨了C++中复杂表达式的执行顺序问题。通过"糊涂实习生"的比喻，生动说明了当表达式包含多个副作用（如i++）时，编译器可能产生不可预测的行为。文章重点分析了i = ++i + 1;、cout << i << i++;等典型未定义行为案例，解释了为何这些代码在不同编译器或优化级别下可能产生不同结果。 核心观点包括： C++标准未规定某些运算符的操作数求值顺序 同一表达式中对变量同时读写会导致未定义行为 序列点（如;
spring aop annotation execute order
Justnow_的博客
09-08 1492
我们都知道用spring aop注解方式书写切面类时，通常会遇到这几个注解：@Before – 在目标方法执行前被执行 @After – 在目标方法执行后执行，无论是抛出异常还是正常返回 @AfterReturning – 在目标方法正常执行后执行，可拦截其返回结果 @AfterThrowing – 在目标方法抛出异常后执行，可拦截具体抛出的异常，并对其做处理 @Around – 环绕通知，
【随笔】关于c语言中++自增、--自减运算符混合使用问题
InVoke_Yui的博客
10-23 896
C语言基础巩固——运算符优先级与混合表达式相关 ## 效果图示： 关于a++与++a的问题一直是面试以及课堂上老生常谈的问题，但当两者混合并与其他运算符构成新的表达式时，即便是已从业多年的开发人员，突然面对无论是面试题中还是跑路同行留下的“密码”，难免也要挠两下本已稀疏的头。 void main() { int a = 10; int b = (a++) + (++a) * 3 + (--a) + (a++); printf("%d, %d\n", a, b); // 12,..
Node.js 异步控制流大师：从回调地狱到优雅的顺序执行
2501_93104808的博客
10-31 394
摘要： 本文深入探讨了 Node.js 异步控制流的演进与最佳实践，重点解析了 async/await 的核心原理与应用。从回调地狱到 Promise 链式调用，再到现代 async/await 同步式编码风格，逐步展示了如何优雅管理异步顺序执行。通过实战案例（文件处理管道）演示了顺序任务的串联实现，并介绍了高级混合模式，如带重试的请求和并行任务优化。关键点包括：异步流程的演进本质、async/await 的底层 Promise 机制，以及顺序/并行混合场景的灵活运用。最终帮助开发者编写可维护的高效异步代码
3、将 Stateflow 大子集转换为混合 CSP
w7x8y9z的博客
06-12 73
本文详细介绍了将 Stateflow 大子集模型转换为形式语言 Hybrid CSP 的过程。内容涵盖状态入口与出口动作、连接点遍历策略、事件广播机制、图表执行顺序、连续演化处理等多个方面，并结合代码优化技术如过程内联、窥孔优化、常量传播和死代码消除，有效简化了生成的 Hybrid CSP 代码。通过一组全面的基准测试和大型案例研究（如秒表和实时发布订阅协议模型），验证了转换方法的有效性和广泛覆盖性。此外，文章还讨论了未来在代码优化和验证方面的改进方向，旨在提升对复杂 Stateflow 模型的支持能力。
js的setTimeout和Promise---同步异步和微任务宏任务
weixin_34050389的博客
01-26 1303
久经前端开发沙场，会经历各式各样的需求，处理这些需求时候，会使用各种各样的api和功能，这里集中对setTimeout和Promise的异步功能进行讨论一下。 单独使用的执行模式 这里就使用Promise作为例子，来探究一下单独使用它，会有哪些注意点。 1.最初的试探 执行代码，Promise的基本使用： let fn = () =...
自著——30天自制红孩儿解释器 第四天 挑战四则混合运算
红孩儿编程大师
09-11 396
自著——30天自制红孩儿解释器 第四天 挑战四则混合运算 在第三天的3.1程序中，如果输入 1+34+2/20 输出是1.85 这个结果明显是错误的。 原因在于程序没有正确地处理因优先级而引起的运算顺序的变化。 即需要先算乘除法，然后算加减法。在优先级相同时，才按照从 左到右的顺序进行运算。 今天就来解决这个问题。 对于四则混合运算的表达式的BNF定义如下： <simple_exp> :== <term> | <term> + <term> | &l
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值