Day09 - 子类父类多继承多层继承多态

news2024/9/22 23:23:57

1. 子类中访问父类中的私有属性和私有方法

如果想使用父类中的私有属性和私有方法,那么就需要在父类中,为这些私有的属性和方法,提供相应的公有的接口方法来间接访问

2. 如何为父类中的属性进行初始化

在子类中如果定义了自己的初始化方法,那么这时父类的初始化方法就不会再执行了
那么就导致父类中定义的属性无法初始化,子类对象就无法使用继承自父类的属性
如果想正常初始化,需要在子类的初始化方法中,手动调用父类的初始化方法
现阶段调用格式:
父类名.__init__(self,父类中需要属性参数列表)

'''
子类初始化父类的属性
'''

# 父类
class Father(object):
    def __init__(self,name):
        print('Father Init Run ...')
        self.name = name


# 子类
class Son(Father):
    def __init__(self,name, age):
        #　因为子类提供了 init 方法后，那么在使用子类实例对象时，就会调用 子类自己 init 方法，
        # 那么就不会再调用 父类的init方法了，父类当中的属性就不会有绑定的机会，所以这时是没有父类的属性的
        # 如果想父类中的属性可以得到，需要执行父类中的init方法
        # 父类名.init()
        Father.__init__(self, name)
        print('Son Init run ..')
        self.age = age



# 测试
s = Son('Tom', 12)
print(s.name)
print('age:', s.age)

3. 子类中重写和调用父类的方法

在子类继承父类时,子类会拥有父类中的方法.
但是子类并不需要或不满足父类方法中提供的功能,这时就需进行对父类方法重写

重写之后,调用该方法时,执行谁?
答案: 调用重写后子类中的方法

'''
子类重写父类中的方法
'''


# 父类
class Father(object):
    # 实现一个治病
    def cure(self):
        print('父类是个老中医，使用中医古法治病')


# f = Father()
# f.cure()

# 子类
class Son(Father):
    # 子类也是一个大夫，也有治病的功能
    def cure(self):
        # 直接使用 父类名.方法名 形式来引用父类的功能
        Father.cure(self)
        print('子类出国深造，学成以后，使用中西医结合方法治病')


s = Son()
s.cure()

4. 子类方法中调用父类的同名方法

子类调用父类同名方法，第一种方法是：指名道姓，重新在子类中将每个父类方法调用一遍，这种方法代码冗余，但是有多继承的话，也能解决问题；第二种方法是：使用super代替父类的名字调用父类，因此要调用爷爷类的同名方法，那就要在父类中同样使用super代替，所以说super方法比较适合单一继承。

#  super无参数写法
super().__init__()
super().要调用的函数()

5. 多层继承

继承关系有多层,祖孙三代

查找方法:

父类名.方法名(self)

'''
多层继承
'''


class A(object):
    def a(self):
        print('a function')


class B(A):
    def b(self):
        print('b function')


class C(B):
    # C类中重写了B类中的方法
    def b(self):
        B.b(self)
        print('b in C function')

    def c(self):
        print('c function')


class D(C):
    def d(self):
        print('d function')


# 测试
d = D()
d.a()
d.b()
d.c()
d.d()

'''
多层继承
'''


class A(object):
    def __init__(self, a):
        self.a = a


class B(A):
    def __init__(self, a, b):
        A.__init__(self, a)
        self.b = b


class C(B):
    def __init__(self, a, b, c):
        B.__init__(self, a, b)
        self.c = c


class D(C):
    def __init__(self, a, b, c, d):
        C.__init__(self, a, b, c)
        self.d = d


# 测试
d = D(1, 2, 3, 4)
print(d.a)
print(d.b)
print(d.c)
print(d.d)

d.__dict__#保存信息到字典
D.__dict__

6. 多继承

格式:
class 类名(父类名1,.....):
	pass

'''
多层继承：纵向
多继承： 横向

'''


# 定义一个父亲类
class Father(object):
    def func_fa(self):
        print('Father Function ...')


# 定义一个母亲类
class Mother(object):
    def func_mo(self):
        print('Mother function ...')


# 上面的两个类，有一个共同子类
class Son(Father, Mother):
    def play(self):
        print('Son play...')


# 测试
s = Son()
s.play()
s.func_fa()
s.func_mo()

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

7. 多继承的初始化

'''
多继承的初始化问题
'''


# 定义一个人类
# 在这种 继承关系 上，这个共同的父类 Person 会被初台化多次，这是继承时的问题
# 是否 父类名调用 实始化方法的时候 引起的
class Person(object):
    def __init__(self, aaa):
        print('Person Init ...')
        self.aaa = aaa


class Father(Person):
    def __init__(self, aaa, name):
        Person.__init__(self, aaa)
        print('Father Init ...')
        self.name = name


class Mother(Person):
    def __init__(self, aaa, age):
        Person.__init__(self, aaa)
        print('Mother Init ...')
        self.age = age


class Son(Father, Mother):
    def __init__(self, aaa, name, age, gender):
        Father.__init__(self, aaa, name)
        Mother.__init__(self, aaa, age)
        print('Son Init ...')
        self.gender = gender


# 测试
s = Son(1, 'Tom', 12, '男')
print(s.aaa)
print(s.name)
print(s.age)
print(s.gender)


'''
多继承的初始化问题的解决
'''


# 定义一个人类

class Person(object):
    def __init__(self, aaa):
        print('Person Init ...')
        self.aaa = aaa


class Father(Person):
    def __init__(self, aaa, name, age):
        super(Father, self).__init__(aaa, age)
        print('Father Init ...')
        self.name = name


class Mother(Person):
    def __init__(self, aaa, age):
        super(Mother, self).__init__(aaa)
        print('Mother Init ...')
        self.age = age


class Son(Father, Mother):
    def __init__(self, aaa, name, age, gender):
        # 参数二是当前类的实例对象
        # 参数一是当前类名
        # 在参数二对象的所属类的mro关系 中找参数一的下一个类进行实始化
        super(Son, self).__init__(aaa, name, age)
        print('Son Init ...')
        self.gender = gender


# 测试
s = Son(1, 'Tom', 12, '男')
print(s.aaa)
print(s.name)
print(s.age)
print(s.gender)

print(Son.__mro__)
'''
这个顺序关系是解释器在执行代码 时，自动确认的我们无法干涉
(<class '__main__.Son'>,
 <class '__main__.Father'>, 
 <class '__main__.Mother'>, 
 <class '__main__.Person'>, 
 <class 'object'>)
'''

# f = Father('tom',1)
print(Father.__mro__)


父类名调用  理解
super()调用  使用
super(类名，self) 了解 

'''
多继承的初始化问题的解决
'''


# 定义一个人类

class Person(object):
    def __init__(self, aaa):
        print('Person Init ...')
        self.aaa = aaa


class Father(Person):
    def __init__(self, name, *args):
        # super(Father, self).__init__(*args)
        super().__init__(*args)
        print('Father Init ...')
        self.name = name


class Mother(Person):
    def __init__(self, age, *args):
        # super(Mother, self).__init__(*args)
        super().__init__(*args)
        print('Mother Init ...')
        self.age = age


class Son(Father, Mother):
    def __init__(self, gender, name, age, aaa):
        # 参数二是当前类的实例对象
        # 参数一是当前类名
        # 在参数二对象的所属类的mro关系 中找参数一的下一个类进行实始化
        # super(Son, self).__init__(name,age,aaa)
        super().__init__(name, age, aaa)
        print('Son Init ...')
        self.gender = gender


# 测试
# s = Son(1, 'Tom',12,'男')
s = Son('男', 'Tom', 12, 1)
print(s.aaa)
print(s.name)
print(s.age)
print(s.gender)

print(Son.__mro__)
'''
这个顺序关系是解释器在执行代码 时，自动确认的我们无法干涉
(<class '__main__.Son'>,
 <class '__main__.Father'>, 
 <class '__main__.Mother'>, 
 <class '__main__.Person'>, 
 <class 'object'>)
'''

f = Father('Jack', 2)
print(f.aaa)
print(f.name)
print(Father.__mro__)

super执行过程:
在 self 这个对象的所属类中,通过 __mro__ 找到方法解析顺序
在顺序中,找当前类名的下一个类来初始化或查找方法

'''
类的继承书写顺序会影响mro顺序
'''


class A(object):
    pass


class B(A):
    pass


class C(A):
    pass


# class D(B,C):
# (<class '__main__.D'>, < class '__main__.B' >, < class '__main__.C' >, < class '__main__.A' >, < class 'object' > )

class D(C, B):
    # (<class '__main__.D'>, <class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>)
    pass


print(D.__mro__)


在多继承时,如果继承的多个类同时继承同一个父类,那么这时会出现初始化问题
这个共同父类会被初始化多次.

类名.__mro__ 得到了一个元组,元组中的元素是当前类在继承关系上的一个顺序

方法解析顺序
method relational ordered

这个顺序不是我们确定的,是由在确定某个类的继承关系关系后,由解释器来确定这个顺序

'''
多重多继承时，方法的查找顺序也参考MRO
'''


class A(object):
    def show(self):
        print('A _ Show Run ...')

    def info(self):
        print('A - Info run ...')


class B(A):
    def show(self):
        print('B _ Show Run ...')


class C(A):
    def show(self):
        print('C _ Show Run ...')

    def info(self):
        # super().info()
        # A.info(self)
        print('C - Info run ...')


class D(B, C):
    def show(self):
        super().show()
        A.show(self)
        print('D _ Show Run ...')


d = D()
d.show()
d.info()


super对象是基于类的mro顺序来对当前类进行初始化的
基于这个mro顺序可以保证,所有的继承关系的上类,都只执行一次

'''
多继承的初始化问题的解决
'''


# 定义一个人类

class Person(object):
    def __init__(self, aaa):
        print('Person Init ...')
        self.aaa = aaa


class Father(Person):
    def __init__(self, name, *args):
        super(Father, self).__init__(*args)
        print('Father Init ...')
        self.name = name


class Mother(Person):
    def __init__(self, age, *args):
        super(Mother, self).__init__(*args)
        print('Mother Init ...')
        self.age = age


class Son(Father, Mother):
    def __init__(self, gender, name, age, aaa):
        # 参数二是当前类的实例对象
        # 参数一是当前类名
        # 在参数二对象的所属类的mro关系 中找参数一的下一个类进行实始化
        super(Son, self).__init__(name, age, aaa)
        print('Son Init ...')
        self.gender = gender


# 测试
# s = Son(1, 'Tom',12,'男')
s = Son('男', 'Tom', 12, 1)
print(s.aaa)
print(s.name)
print(s.age)
print(s.gender)

print(Son.__mro__)
'''
这个顺序关系是解释器在执行代码 时，自动确认的我们无法干涉
(<class '__main__.Son'>,
 <class '__main__.Father'>, 
 <class '__main__.Mother'>, 
 <class '__main__.Person'>, 
 <class 'object'>)
'''

f = Father('Jack', 2)
print(f.aaa)
print(f.name)
print(Father.__mro__)

mro -> 一个类的继承书写顺序会影响mro顺序

8. 多继承调用指定父类中方法

	父类名.方法（）
	super().方法()

9. 多态

多种形态
程序中的意义:
	当调用一个方法名的时候,得到的结果不同
	在一般的面向对象语言中,多态是由继承来实现的
	但是在python中,python,天生具有多态性


鸭子类型： Duck Typing
	一只鸟如果长的鸭子,叫声像鸭子,那么就认为它就是鸭子

'''
多态
'''


# 标准多态

class Father(object):
    def cure(self):
        print('老中医使用中医治病')


class Son(Father):
    def cure(self):
        print('小大夫使用中西医结合治病')


class Dog(object):
    def bark(self):
        print('Won won ...')


class AnimalDoctor(object):
    def cure(self):
        print('我是个兽医，主要给动物治病，但是也能给人凑合治一下')


# 病人类
class Person(object):
    # 需要一个大夫给他治病
    def need_doctor(self, doctor):
        doctor.cure()


# 测试
p = Person()

p.need_doctor(Father())
p.need_doctor(Son())
# p.need_doctor(Dog())
p.need_doctor(AnimalDoctor())

10. 实例对象属性和实例对象方法

以 对象名.xxx  的形式调用的都是实例的属性或实例的方法

'''
实例属性和实例 方法
'''


class Cat(object):
    def __init__(self, name):
        # 定义一个实例 属性
        self.name = name

    # 定义了一个实例方法
    def info(self):
        print(self.name)

    def show(self):
        print('Show Run :')
        self.info()


# 测试
tom = Cat('Tom')
# 使用实例属性
print(tom.name)
# 使用实例方法
tom.info()
tom.show()

# Python中万物皆对象
# print(Cat.name)
Cat.show()

# 结论：
# 为什么类名不能调用 实例 对象属性和实例对象方法呢？
# 因为类对象存在时，不一定有实例对象存在
# 实例属性和实例 方法只能由实例对象调用

​ 实例属性和实例方法只能由实例对象调用

11. 类对象和类属性

类属性可以使用实例对象来引用,但是不能修改
一般情况下:类属性 都只使用 类对象 来调用

类对象.类属性

'''
类对象和类属性
'''


class ClassRoom(object):
    # 当定义一个类属性时，相当于这个类中的全局变量
    # 该类的所有对象都 可以使用该 类属性
    # 可以在所有的对象间进行数据共享
    center_kong_tiao = '格力空调'

    # 实例方法
    def show(self):
        print('实例方法中去访问类属性：')
        print(ClassRoom.center_kong_tiao)


cr901 = ClassRoom()
print(cr901.center_kong_tiao)

cr902 = ClassRoom()
print(cr902.center_kong_tiao)

cr903 = ClassRoom()
print(cr903.center_kong_tiao)

# cr901.center_kong_tiao = '海尔空调'
ClassRoom.center_kong_tiao = '海尔空调'
print(cr901.center_kong_tiao)
print(cr902.center_kong_tiao)
print(cr903.center_kong_tiao)

cr901.show()

扩展

'''
扩展：属性和方法的保存位置
'''

class Cat(object):
    def __init__(self,name):
        self.name = name
        self.__age = 1

    def public_method(self):
        print('公有的对象方法')

    def __private_method(self):
        print('私有的对象方法')


tom = Cat('Tom')
jack = Cat('Jack')
# __dict__ 是一个魔法属性，用来保存当前对象的所有的成员
print(Cat.__dict__)
print(tom.__dict__)
print(jack.__dict__)

tom.public_method()

Cat.public_method(tom)
Cat.public_method(jack)

def display():
    print('Display')

display()

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/176963.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

尚硅谷AJAX教程

尚硅谷AJAX教程

优点&#xff1a;无需刷新页面获取数据&#xff0c;允许你根据用户事件来更新部分页面内容 缺点&#xff1a;没有浏览历史&#xff0c;不能回退&#xff0c;存在跨域&#xff0c;SEO不友好 原生XHR请求 get请求 <body><button>获取数据</button><scri…
阅读更多...
弹性可微调，基于LCN光敏材料的触觉模拟系统

弹性可微调，基于LCN光敏材料的触觉模拟系统

对于AR/VR体验来讲&#xff0c;体感、触觉模拟很重要&#xff0c;但现阶段还没有一种方便消费者使用、轻便的体感方案&#xff0c;因此Meta等公司不断在探索更好的体感技术。比如近期&#xff0c;Nature发表了一项来自荷兰埃因霍芬理工大学的新研究&#xff0c;该研究由Meta Re…
阅读更多...
svg的path标签的d属性

svg的path标签的d属性

<svgwidth"200"height"200"viewBox"0 0 200 200"style"border: 1px solid red"><pathd"M10 10 L110 10 L110 110 L10 110 Z"fill"none "stroke"green"></path></svg>运行效果…
阅读更多...
Redux Toolkit 调用 API 的四种方式

Redux Toolkit 调用 API 的四种方式

Redux Toolkit 调用 API 的四种方式 上篇笔记写的比较乱&#xff0c;加上这回又学了点新的东西&#xff0c;所以重新整合一下。 本地 API 用的是 json-server&#xff0c;端口设置在 3005&#xff0c;数据包含&#xff1a; {"users": [{"id": 1,"n…
阅读更多...
数据分析-深度学习 Pytorch Day9

数据分析-深度学习 Pytorch Day9

迁移学习通过利用数据、任务或模型之间的相似性&#xff0c;将在旧领域学习过的模型应用于新领域来求解新问题。生活中常用的“举一反三”、“照猫画虎”就很好地体现了迁移学习的思想。利用迁移学习的思想&#xff0c;可以将已有的一些训练好的模型&#xff0c;迁移到我们的任…
阅读更多...
【Kotlin】泛型 ② ( 可变参数 vararg 关键字与泛型结合使用 | 使用 [] 运算符获取指定可变参数对象 )

【Kotlin】泛型 ② ( 可变参数 vararg 关键字与泛型结合使用 | 使用 [] 运算符获取指定可变参数对象 )

文章目录一、可变参数 vararg 关键字与泛型结合使用二、使用 [] 运算符获取指定可变参数对象一、可变参数 vararg 关键字与泛型结合使用 如果 泛型类型 T 的参数 是 vararg 可变参数 , 则在接收 可变参数 时 , 需要使用 Array<out T> 类型 的变量进行接收 ; 参数为 vara…
阅读更多...
分房管理系统Rose模型设计过程

分房管理系统Rose模型设计过程

文章目录 一、模型总体设计 1 创建系统的Use Case 视图 2 创建系统的 Logical 视图 3 创建系统的 Class 框图 4 创建系统的 StateChart 框图 5 创建系统的 Activity 框图 二、软件模块结构图设计 1 根据系统功能进行第一级分解 2 完成第二级分解 3 完成第三级分解 4 整合得到完…
阅读更多...
从零开始的python基础教程

从零开始的python基础教程

一、Getting Started 如果使用的是mac或linux系统&#xff0c;需要输入 python3 比如运行 python3 app.py 可以直接在终端的>>>符号后执行python代码 print("*" * 10) 1、实现 在相关终端当运行“python”为CPython&#xff0c;这是python的默认实现 Jy…
阅读更多...
大数据--spark

大数据--spark

什么是SparkApache Spark 的架构基础是弹性分布式数据集 (RDD)&#xff0c;这是一种只读的多组数据项&#xff0c;分布在机器集群上&#xff0c;以容错方式维护。[2] Dataframe API 作为 RDD 之上的抽象发布&#xff0c;随后是 Dataset API。在 Spark 1.x 中&#xff0c;RDD 是…
阅读更多...
39-剑指 Offer 41. 数据流中的中位数

39-剑指 Offer 41. 数据流中的中位数

题目 如何得到一个数据流中的中位数&#xff1f;如果从数据流中读出奇数个数值&#xff0c;那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值&#xff0c;那么中位数就是所有数值排序之后中间两个数的平均值。 例如&#xff0c; [2,3,4] 的中位…
阅读更多...
50个常用的 Numpy 函数详解

50个常用的 Numpy 函数详解

目录 一、创建数组 1、Array 2、Linspace 3、Arange 4、Uniform 5、Random.randint 6、Random.random 7、Logspace 8、zeroes 9、ones 10、full 11、Identity 二、数组操作 12、min 13、max 14、unique 15、mean 16、medain 17、digitize 18、reshape 19、…
阅读更多...
详解1247：河中跳房子(二分经典例题)

详解1247：河中跳房子(二分经典例题)

1247&#xff1a;河中跳房子【题目描述】每年奶牛们都要举办各种特殊版本的跳房子比赛&#xff0c;包括在河里从一个岩石跳到另一个岩石。这项激动人心的活动在一条长长的笔直河道中进行&#xff0c;在起点和离起点L远 (1 ≤ L≤ 1,000,000,000) 的终点处均有一个岩石。在起点和…
阅读更多...
《Unity Shader 入门精要》第6章 Unity 中的基础光照

《Unity Shader 入门精要》第6章 Unity 中的基础光照

第6章 Unity 中的基础光照 6.1 我们是如何看到这个世界的 通常来说我们要模拟真实的光照环境来生成一张图像&#xff0c;需要考虑3种物理现象&#xff1a; 首先&#xff0c;光线从光源&#xff08;light source&#xff09;中被发射出来然后&#xff0c;光线和场景中的一些物…
阅读更多...
JavaScript while 循环

JavaScript while 循环

文章目录JavaScript while 循环while 循环do/while 循环比较 for 和 while笔记列表JavaScript while 循环 只要指定条件为 true&#xff0c;循环就可以一直执行代码块。 while 循环 while 循环会在指定条件为真时循环执行代码块。 语法 while (条件) {需要执行的代码 }本例中…
阅读更多...
Redis内部的阻塞式操作以及应对方法

Redis内部的阻塞式操作以及应对方法

Redis之所以被广泛应用&#xff0c;很重要的一个原因就是它支持高性能访问&#xff0c;也正因为这样&#xff0c;我们必须要重视所有可能影响Redis性能的因素&#xff0c;不仅要知道具体的机制&#xff0c;尽可能避免异常的情况出现&#xff0c;还要提前准备好应对异常的方案。…
阅读更多...
MySQL进阶篇之索引2

MySQL进阶篇之索引2

02、索引 前四节内容&#xff1a;https://blog.csdn.net/kuaixiao0217/article/details/128753999 2.5、SQL性能分析 2.5.1、查看执行频次 1、SQL执行频率 MySQL客户端连接成功后&#xff0c;通过show [session|global] status命令可以提供服务器状态信息。 通过如下指令…
阅读更多...
Computer architecture Cyber security Quantum computing交友

Computer architecture Cyber security Quantum computing交友

如果您也是computer architecture方向的博士硕士&#xff0c;希望交个朋友&#xff0c;欢迎后台私信。 当然&#xff0c;如果您也是 Cyber SecurityQuantum ComputingHigh Performance Computing 方向的博士硕士&#xff0c;想要交流&#xff0c;也可以私信。
阅读更多...
学习记录669@项目管理之项目合同管理

学习记录669@项目管理之项目合同管理

有效合同原则 有效合同应具备以下特点: (1)签订合同的当事人应当具有相应的民事权利能力和民事行为能力。 (2)意思表示真实。 (3)不违反法律或社会公共利益 与有效合同相对应&#xff0c;需要避免无效合同。无效合同通常需具备下列任一情形: (1)一方以欺诈、胁迫的手段订立合…
阅读更多...
【模拟CMOS集成电路】电路失调与CMRR—— 随机失调与系统失调分析（1）

【模拟CMOS集成电路】电路失调与CMRR—— 随机失调与系统失调分析（1）

电路失调与CMRR—— 随机失调与系统失调分析&#xff08;1&#xff09;前言1.1失调1.2失调电路模型1.2.1随机失调电路模型&#xff08;1&#xff09;电阻失配&#xff08;2&#xff09;跨导失配&#xff08;3&#xff09;电流镜的随机失调1.2.2系统失调前言 本文主要内容是失调…
阅读更多...
深入剖析JVM垃圾收集器

深入剖析JVM垃圾收集器

文章目录前言1、新生代垃圾收集器1.1、Serial1.2、ParNew1.3、Parallel Scavenge2、老年代垃圾收集器2.1、Serial Old2.2、Parallel Old2.3、CMS&#xff08;Concurrent Mark Sweep&#xff09;3、全堆垃圾收集器3.1、Garbage First&#xff08;G1&#xff09;前言 参考资料&am…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023