继承子父类中的成员变量的内存图解

最新推荐文章于 2025-04-08 22:51:27 发布

精逗儿

最新推荐文章于 2025-04-08 22:51:27 发布

阅读量783

点赞数

CC 4.0 BY-SA版权

分类专栏： Java

本文链接：https://blog.youkuaiyun.com/qq_34475234/article/details/84324832

Java 专栏收录该内容

1 篇文章

订阅专栏

本文通过一个具体的Java代码示例，展示了子类如何继承父类的属性，并在子类中覆盖和使用父类的方法。深入探讨了this关键字和super关键字的用法，以及它们在调用属性和方法时的区别。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

代码

class Fu
{
	int num = 4;
}
class Zi extends Fu
{
	int num = 5;
	void show()
	{
		System.out.print(this.num+"..."+super.num);
	}
}
class ExtendsDemo2
{
	public static void main(...)
	{
		Zi z = new Zi();
		z.show();
	}
}

内存图解

子类父类内存图解

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

精逗儿

关注关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

第八章第13节面向对象(继承后子类父类成员变量内存图)

菜鸟学院

02-17

266

第八章第13节面向对象(继承后子类父类成员变量内存图)

Java基础_Java编程思想_面向对象之继承关系中类成员的使用

9.冄2.7.號的博客

03-11

316

继承关系中类成员的使用继承关系中子父类成员变量的使用需求：子父类中定义了同名的成员变量，如何使用？分析 A：子类中定义成员变量int price，默认值为10 B：父类中定义成员变量int price，默认值为20 C：子类成员方法中定义局部变量int price，值为5 D：在子类成员方法中分别输出三个price的值图解代码演示 //父类 public class Fu { int num = 30; } //子类 public class Zi extends Fu {

参与评论您还未登录，请先登录后发表或查看评论

【精选】java继承进阶，子类继承父类（内存图、内存分析工具）

人若无名，便可专心练剑

02-05

706

在 Java 中，子类继承父类意味着子类会获得父类的非私有属性和方法，并且可以在子类中使用它们。通过继承，子类可以重用父类的代码，并有选择地覆盖（重写）父类的方法，添加自己的业务逻辑。

JAVA面向对象中继承的使用以及子父类中成员变量的内存图解

weixin_42947972的博客

10-04

676

继承实例代码: 我们这里为了简便就不把类里面的变量定义成私有,并提供间接访问了 class Person{ //把下面内容相同抽取出来的部分 String name; int age; } class Student extends/*继承*/ Person{ public void study() //功能(动作) { ...

子类父类内存图

windows下搭建virtualenv、virtualenvwrapper虚拟环境

11-20

277

先进堆内存，初始化成员变量，再调用构造方法子类中，super()的方式，调用父类的构造方法 super()调用的是父类的空参数构造，子类构造方法第一行super语句，调用父类的构造方法 super（参数）调用的是父类的有参数构造方法 1、2两步：子类文件.class通过super找到父类文件.class，标明了位置所在 ...

Java继承子类的内存模型

Johnchy6112014的博客

01-20

478

package subClass; class ParentClass { public void fun(){ System.out.println("ParentClass--->fun()"); } } class SubClass extends ParentClass{ int i=100; Str...

【笔记】Java的多态概述、父类引用指向子类对象的内存图、多态使用场景及其内存图解、多态中成员变量的使用及内存图解（instanceof关键字的用法）、多态的好处和弊端

qq_51843109的博客

03-28

1401

文章目录一、多态概述二、父类引用指向子类对象的内存图三、多态使用场景及其内存图解四、多态的好处和弊端一、多态概述二、父类引用指向子类对象的内存图三、多态使用场景及其内存图解四、多态的好处和弊端 ...

【笔记】Java中继承关系中成员变量的使用特点、使用成员变量的内存图解、this和super的区别、继承关系中成员方法的使用格式、使用成员方法的内存图解、继承关系中构造方法的使用特点

qq_51843109的博客

03-18

475

文章目录一、继承关系中成员变量的使用特点二、使用成员变量的内存图解三、this和super的区别四、继承关系中成员方法的使用格式五、使用成员方法的内存图解六、继承关系中构造方法的使用特点一、继承关系中成员变量的使用特点二、使用成员变量的内存图解三、this和super的区别四、继承关系中成员方法的使用格式五、使用成员方法的内存图解六、继承关系中构造方法的使用特点 ...

图解Java继承内存分配

01-20

继承的基本概念： ... 　分析以上程序示例，主要疑惑点是“子类继承父类的成员变量，父类对象是否会实例化？私有成员变量是否会被继承？被继承的成员变量在哪里分配空间？” 　1：虚拟机加载ExtendsD

C++类继承内存布局详解图（一目了然）

07-24

在本文中，我们将从C结构的布局开始，逐步介绍单继承、多重继承、虚继承的内存布局，成员变量和成员函数的访问，以及虚函数的调用机制。首先，让我们从C结构的布局开始。C结构是C++的基础，C++也基本上兼容C。特别...

41）子类和父类的内存关系

weixin_30536513的博客

01-12

230

1）通过下面的布局我们看一下拥有继承关系的两个类之间的内存关系　　　　　　　　　　　　　　　　　　　　说明：1）我的Student3 继承 Student这个类的然后在子类Student3的前半部分内存块是代表父类Student的一些属性的存储情况　　　　　　　2）下面是子类自己的一些特有的属性信息。　　　　　　　3）子类对象...

java中父类子类的成员变量和成员方法在内存分配上的一些理解

fxxashelly的博客

07-01

2126

先声明，以下是个人自己的理解(我也怕误人子弟)，如有错误请指出一起学习交流。先上代码：package myTest; class A { int num = 5; A() { show(); } public void show() { System.out.println("A" + num); } } class B extends A { int num = 10...

【Python】面向对象 - 继承 ② ( 子类重写父类成员 | 子类调用父类重名成员 | 子类中使用父类类名调用父类成员 | 子类中使用 super 调用父类成员 )

让学习成为一种习惯 ( 韩曙亮の技术博客 )

07-12

2521

一、子类重写父类成员 1、子类重写父类成员语法 2、代码示例 - 子类重写父类成员二、子类调用父类重名成员 1、子类调用父类重名成员语法 2、代码示例 - 子类中使用父类类名调用父类成员 3、代码示例 - 子类中使用 super 调用父类成员

【Java】面向对象之继承篇

weixin_60719453的博客

10-20

2312

目录一、前言二、继承什么是继承呢？继承的好处与弊端继承的使用场景？继承的格式：继承的特点：重写的概念： super关键字 super和this的比较一、前言前面我也们讲述了相关封装的，现在我们先认识的继承的概念和使用。二、继承什么是继承呢？继承在显示生活中也不少见，比如继承财产之类的，在我们java学习中也有类似的使用，继承者称作子类也叫派生类，被继承者称作父类、基类或超类，objec类是所有类的父类（后期介绍）继承的好处与弊端

关于子类能不能继承和重写父类的静态变量和静态方法

Code_Mei

01-23

3398

关于子类能不能继承和重写父类的静态成员变量和静态成员方法子类可以继承父类的静态成员变量和静态成员方法 // 父类 public class Father { // 父类的静态成员变量age public static int age = 18; // 父类的静态成员方法print() public static void print() { System.out.println("我是父类的print()方法！"); } } // 子类 pu

Java中子类重写（overwriting）父类的方法

最新发布

08-02

<think>我们正在讨论Python中类继承的内部机制。根据用户提供的引用和之前的问题，我们需要详细解释子类继承父类时内部是如何工作的，包括方法解析顺序（MRO）、super()函数的作用、构造函数的执行顺序等。根据引用内容，我们可以总结以下几点： 1. 子类继承父类时，如果子类没有重写__init__方法，则实例化子类时会自动调用父类的__init__方法（引用[3]）。 2. 如果子类重写了__init__方法，那么子类实例化时不会自动调用父类的__init__方法，除非显式使用super()或者父类名来调用（引用[2][3]）。 3. super()函数有两种写法：一种是super(子类名, self).__init__(参数)，另一种是简写super().__init__(参数)（引用[2]）。 4. 在多重继承中，方法解析顺序（MRO）按照从左到右的顺序搜索父类（引用[4]），并且Python使用C3线性化算法来解决钻石继承问题（引用[4]中的示例展示了多重继承的调用顺序）。 5. 私有属性（双下划线开头）在子类中不能直接访问，因为Python对其进行了名称改写（name mangling）（引用[1]中提到私有方法被改名为_Animal__heshui()，但引用中没有直接给出私有属性的例子，我们可以补充）。现在，我们将详细解释子类继承父类时的内部运行机制： ### 1. 类定义阶段当定义一个类时，Python会创建一个类对象，并记录其基类（父类）。类对象中存储了类属性和方法。继承关系通过类的`__bases__`属性来体现。 ### 2. 方法解析顺序（MRO）当子类继承父类（可能多个父类）时，Python通过C3线性化算法计算出一个方法解析顺序（MRO），这个顺序决定了在查找方法时的顺序。我们可以通过`类名.mro()`查看。例如，在引用[4]中，类`sample`同时继承`speaker`和`student`，而`student`又继承`people`。那么`sample`的MRO顺序为： ```python sample.mro() # 输出: [sample, speaker, student, people, object] ``` 注意：在多重继承中，当子类调用一个方法时，会按照MRO列表从左到右查找。 ### 3. 实例化过程当创建子类实例时，主要步骤如下： 1. 首先，Python会为新实例分配内存，并创建一个空的实例对象。 2. 然后，调用子类的`__init__`方法（如果子类没有定义`__init__`，则按照MRO顺序查找第一个父类的`__init__`）。 3. 在子类的`__init__`方法中，如果调用了`super().__init__()`，则按照MRO顺序调用下一个类的`__init__`方法（注意：不一定是直接父类，而是MRO顺序中的下一个类）。例如，在引用[2]中： ```python class Son(Father): def __init__(self, name): super(Son, self).__init__(name) # 调用父类Father的__init__ print("hi") self.name = name ``` 这里，`super(Son, self)`会返回一个代理对象，它按照MRO顺序（此时MRO为[Son, Father, object]）查找下一个类，即Father。因此，执行`Father.__init__`。 ### 4. 使用父类名直接调用除了使用super()，还可以直接使用父类名调用父类的方法，如引用[2]和引用[4]中所示： ```python class student(people): def __init__(self, n, a, w, g): people.__init__(self, n, a, w) # 直接调用父类people的__init__ self.grade = g ``` 这种方式不会按照MRO顺序，而是直接调用指定父类的方法。在多重继承中，如果多个父类都需要初始化，那么需要显式调用每个父类的初始化方法（如引用[4]中的sample类）。 ### 5. 私有成员的继承在父类中，以双下划线开头的属性或方法会被名称改写（name mangling），形式为`_类名__属性名`。子类无法直接访问父类的私有成员，因为改写后的名称包含了父类的类名。例如： ```python class Parent: def __init__(self): self.__private = 10 # 实际被改写为_Parent__private class Child(Parent): def get_private(self): # 下面这样访问是错误的，因为子类中没有_Child__private，而是_Parent__private # return self.__private # 会报错 return self._Parent__private # 可以这样访问，但不推荐 c = Child() print(c.get_private()) # 输出10 ``` 虽然可以这样访问，但破坏了封装性，不推荐。 ### 6. 多重继承的初始化在多重继承中，使用super()时需要注意，它会按照MRO顺序依次调用各个父类的初始化方法。而直接使用父类名调用则不会自动处理这种顺序，可能导致某些父类被多次初始化或遗漏。例如引用[4]中的多重继承示例： ```python class sample(speaker, student): def __init__(self, n, a, w, g, t): student.__init__(self, n, a, w, g) speaker.__init__(self, n, t) ``` 这里，我们显式调用了两个父类的初始化方法。注意，由于student和speaker没有共同的父类（除了object），所以这样调用是安全的。但如果存在钻石继承（即有一个共同的祖先类），则可能造成祖先类被多次初始化。使用super()可以避免这种情况。 ### 7. 方法重写子类可以重写父类的方法。当子类实例调用方法时，首先在子类中查找，如果找不到则按照MRO顺序在父类中查找。例如引用[4]中，student类重写了speak方法，而sample类同时继承student和speaker，且两者都有speak方法。由于在sample的MRO中speaker排在student前面，所以调用的是speaker的speak方法。 ### 总结 - 子类继承父类时，子类实例化会先调用子类的`__init__`，如果子类没有则按MRO顺序查找父类的`__init__`。 - 使用super()可以按照MRO顺序调用父类的方法，避免在多重继承中重复调用。 - 私有成员在子类中不能直接访问，因为名称改写。 - 方法重写后，子类实例调用方法时优先使用子类的方法。下面用一个简单的例子来展示整个流程： ```python class A: def __init__(self): print("A的初始化") self.a = 1 class B(A): def __init__(self): print("B的初始化") super().__init__() # 调用A的初始化 self.b = 2 class C(A): def __init__(self): print("C的初始化") super().__init__() # 调用A的初始化 self.c = 3 class D(B, C): def __init__(self): print("D的初始化") super().__init__() # 按照MRO顺序调用B和C的初始化 self.d = 4 d = D() print(D.mro()) # 输出: [D, B, C, A, object] ``` 执行d=D()时，输出顺序为： ``` D的初始化 B的初始化 C的初始化 A的初始化 ``` 因为MRO顺序是D->B->C->A，所以在D的初始化中调用super()会调用B的初始化，B的初始化中调用super()会调用C的初始化，C的初始化中调用super()会调用A的初始化。 §§相关问题§§ 1. Python 的 MRO 算法在多继承中如何解决钻石继承问题？ 2. 如何在子类中强制调用特定父类的方法（而非按 MRO 顺序）？ 3. Python 的 `@classmethod` 和 `@staticmethod` 在继承中如何工作？ 4. 元类（metaclass）如何影响类的继承机制？</think>### Python 子类继承父类的内部运行机制在 Python 中，子类继承父类时遵循特定的执行流程和内存管理机制。以下是详细的执行原理（结合引用内容）： #### 1. **类定义阶段（内存分配）** - 定义类时 Python 创建独立的类对象存储类属性和方法 - 继承关系通过 `__bases__` 属性建立 - **关键原则**：类属性和方法存储在类对象中，实例化时才创建实例空间 ```python class Parent: class_var = "父类变量" # 存储在父类对象内存空间 ``` #### 2. **实例化过程（核心流程）** 当创建子类实例 `child = Child()` 时： 1. **分配实例内存** - 创建空实例对象 `self` - 初始化实例的 `__class__` 指针指向子类 2. **执行初始化方法** - 优先查找子类 `__init__`（引用[3]） - 若子类未定义 `__init__`，则调用父类 `__init__`（引用[5]） - 若子类定义了 `__init__`： ```python class Child(Parent): def __init__(self, params): # 必须显式调用父类初始化（引用[2][3]） super().__init__(params) # 或 Parent.__init__(self, params) # 子类初始化代码 ``` #### 3. **`super()` 的工作机制** - 按 MRO（方法解析顺序）查找父类（引用[4]） - Python 3 简写 `super()` 等价于 `super(当前类, self)` - **执行顺序**： ```python class Son(Father): def __init__(self, name): super().__init__(name) # 先执行父类初始化 print("hi") # 再执行子类代码 self.name = name # （引用[2][3]） ``` #### 4. **属性继承规则** - **公有属性**：自动继承 ```python class Dog(Animal): def bark(self): print("汪汪汪") xiao_huang = Dog(20, 9) xiao_huang.sleep() # 继承父类方法（引用[1][5]） ``` - **私有属性**（双下划线开头）： - 名称改写为 `_类名__属性名` - 子类无法直接访问（引用[1]） ```python class Parent: __weight = 0 # 实际名称_Parent__weight（引用[4]） ``` #### 5. **多重继承处理** - MRO 顺序决定方法查找优先级（引用[4]） - 钻石继承问题通过 C3 线性化算法解决 - **初始化顺序**： ```python class sample(speaker, student): # 从左到右优先级 def __init__(self, n, a, w, g, t): student.__init__(self, n, a, w, g) # 显式调用特定父类 speaker.__init__(self, n, t) # （引用[4]） ``` #### 6. **方法重写机制** - 子类定义同名方法时覆盖父类实现 - 可通过 `super()` 调用父类原始实现： ```python class student(people): def speak(self): # 重写父类方法 print(f"{self.name}说: 我{self.age}岁") super().speak() # 调用父类实现（引用[4]） ``` ### 内存结构图解 ``` +----------------+ +----------------+ | Child类 | ---> | Parent类 | | - 类属性 | | - 类属性 | | - __init__() | | - __init__() | | - child_method | +----------------+ +----------------+ ^ | +----------------+ | Child实例 | | - 父类属性 | # 通过super()初始化 | - 子类属性 | # 子类__init__添加 +----------------+ ``` ### 关键总结 1. 子类实例化时优先查找子类 `__init__` 2. 必须显式调用 `super().__init__()` 继承父类属性 3. 方法调用按 MRO 顺序查找 4. 私有属性通过名称改写实现隔离 5. 多重继承按从左到右顺序初始化