文章目录
292_了解继承
课程:面向对象 — 继承
目标
- 继承的概念
- 单继承
- 子类重写父类的同名属性和方法
- 子类调用父类的同名属性和方法
- 多层继承
- super()
- 私有属性和私有方法
一、继承的概念
生活中的继承,一般指的是子女继承父辈的财产。
293_拓展经典类和新式类
- 拓展1:经典类或旧式类
不由任意内置类型派生出的类,称之为经典类。
class 类名:
代码
.....
- 拓展2:新式类
class 类名(object):
代码
294_体验继承
Python面向对象的继承指的是多个类之间的所属关系,即子类默认继承父类的所有属性和方法,具体如下:
#父类
class A(object):
def __init__(self):
self.num = 1
def info_print(self):
print(self.num)
#子类B
class B(A):
pass
result = B()
result.info_print() # 1
子类默认继承父类的所有属性和方法,代码实现如下所示:
#继承:子类默认继承父类的所有属性和方法
#1.定义父类
class A(object):
def __init__(self):
self.num = 1
def info_print(self):
print(self.num)
#定义子类,继承父类
class B(A):
pass
#3.创建对象,验证结论
result = B()
result.info_print()
运行结果:
总结:在Python中,所有类默认继承object类,object类是顶级类或基类;其他子类叫做派生类。
295_单继承
二、单继承
故事主线:一个煎饼果子老师傅,在煎饼果子界摸爬滚打多年,研发了一套精湛的摊煎饼果子的技术。师父要把这套技术传授给他的唯一的最得意的徒弟。
分析:徒弟是不是要继承师父的所有技术?
#1.师父类
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#2.徒弟类
class Prentice(Master):
pass
#3.创建对象daqiu
daqiu = Prentice()
#4.对象访问实例属性
print(daqiu.kongfu)
单继承方法的实现,代码显示如下所示:
#1.师父类,属性和方法
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#2.定义徒弟类,继承师父类
class Prentice(Master):
pass
#3.用徒弟类创建对象,调用实例属性和方法
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()
运行结果:
296_多继承
三、多继承
故事推进:daqiu是个爱学习的好孩子,想学习更多的煎饼果子技术,于是,在百度搜素到黑马程序员,报班学习煎饼果子技术。
所谓多继承意思就是一个类同时继承了多个父类。
#1.师父类,属性和方法
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#为了验证多继承,添加school父类
class School(object):
def __init__(self):
self.kongfu = '[黑马煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#2.定义徒弟类,继承师父类
class Prentice(School,Master):
pass
#3.用徒弟类创建对象,调用实例属性和方法
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()
#结论:如果一个类继承多个父类,优先继承第一个弗雷德同名属性和方法
运行结果:
总结:当一个类有多个父类时候,默认使用第一个父类的同名属性和方法。
297_子类重写父类同名属性和方法
四、子类重写父类同名方法和属性
故事:daqiu掌握了师父和培训的技术后,自己潜心钻研出自己的独门配方的一套全新的煎饼果子技术。
#1.师父类,属性和方法
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#为了验证多继承,添加school父类
class School(object):
def __init__(self):
self.kongfu = '[黑马煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#2.定义徒弟类,继承师父类 和 学校类,添加和父类同名的属性和方法
class Prentice(School,Master):
def __init__(self):
self.kongfu = '[独创煎饼果子技术]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#3.用徒弟类创建对象,调用实例属性和方法
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()
#总结:如果子类和父类拥有同名属性和方法,子类创建对象调用属性和方法的时候,调用到的是子类里面的同名属性和方法
运行结果:
298_拓展_mro顺序
print(类名.mro):查看某个类的父类以及这个类的继承关系。
#1.师父类,属性和方法
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#为了验证多继承,添加school父类
class School(object):
def __init__(self):
self.kongfu = '[黑马煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#2.定义徒弟类,继承师父类 和 学校类,添加和父类同名的属性和方法
class Prentice(School,Master):
def __init__(self):
self.kongfu = '[独创煎饼果子技术]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#3.用徒弟类创建对象,调用实例属性和方法
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()
print(Prentice.__mro__)
#结论:如果一个类继承多个父类,优先继承第一个弗雷德同名属性和方法
#总结:如果子类和父类拥有同名属性和方法,子类创建对象调用属性和方法的时候,调用到的是子类里面的同名属性和方法
运行结果:
299_子类调用父类同名方法和属性之思路分析
五、子类调用父类的同名方法和属性
故事:很多顾客都希望也能吃到古法和黑马的技术的煎饼果子。
class Prentice(School,Master):
def __init__(self):
self.kongfu = '[独创煎饼果子配方]'
def make_cake(self):
#如果是先调用了父类的属性和方法,父类属性会覆盖子类属性,故在调用属性前,先调用自己子类的初始化
self.__init__()
print(f'运用{self.kongfu}制作煎饼果子')
#调用父类方法,但是为保证调用到的也是父类的属性,必须在调用方法前,调用父类的初始化
def make_master_cake(self):
Master.__init__(self)
Master.make_cake(self)
self make_School_cake(self):
School.__init__(self)
School.make_cake(self)
300_子类调用父类同名方法和属性之代码实现
子类调用父类同名方法和属性之代码实现,情况如下所示:
#1.师父类,属性和方法
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#为了验证多继承,添加school父类
class School(object):
def __init__(self):
self.kongfu = '[黑马煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#2.定义徒弟类,继承师父类 和 学校类,添加和父类同名的属性和方法
class Prentice(School,Master):
def __init__(self):
self.kongfu = '[独创煎饼果子技术]'
def make_cake(self):
#此处加自己初始化的原因是:如果不加这个自己的初始化,kongfu属性值是上一次调用的init内的kongfu属性值
self.__init__()
print(f'运用{self.kongfu}制作煎饼果子')
#子类调用父类的同名方法和属性:把父类的同名属性和方法再次封装
def make_master_cake(self):
#父类类名.函数()
#再次调用初始化的原因:这里想要调用父类的同名方法和属性,属性在init初始化位置,所以需要再次调用init进行初始化
Master.__init__(self)
Master.make_cake(self)
def make_school_cake(self):
# 父类类名.函数()
# 再次调用初始化的原因:这里想要调用父类的同名方法和属性,属性在init初始化位置,所以需要再次调用init进行初始化
School.__init__(self)
School.make_cake(self)
#3.用徒弟类创建对象,调用实例属性和方法
daqiu = Prentice()
print(daqiu.kongfu)
daqiu.make_cake()
daqiu.make_master_cake()
daqiu.make_school_cake()
daqiu.make_cake()
print(Prentice.__mro__)
#结论:如果一个类继承多个父类,优先继承第一个弗雷德同名属性和方法
#总结:如果子类和父类拥有同名属性和方法,子类创建对象调用属性和方法的时候,调用到的是子类里面的同名属性和方法
运行结果:
301_多层继承
六、多层继承
故事:N年后,daqiu老了,象牙把所有技术传承给自己的徒弟。
#1.师父类,属性和方法
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#为了验证多继承,添加school父类
class School(object):
def __init__(self):
self.kongfu = '[黑马煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#2.定义徒弟类,继承师父类 和 学校类,添加和父类同名的属性和方法
class Prentice(School,Master):
def __init__(self):
self.kongfu = '[独创煎饼果子技术]'
def make_cake(self):
#此处加自己初始化的原因是:如果不加这个自己的初始化,kongfu属性值是上一次调用的init内的kongfu属性值
self.__init__()
print(f'运用{self.kongfu}制作煎饼果子')
#子类调用父类的同名方法和属性:把父类的同名属性和方法再次封装
def make_master_cake(self):
#父类类名.函数()
#再次调用初始化的原因:这里想要调用父类的同名方法和属性,属性在init初始化位置,所以需要再次调用init进行初始化
Master.__init__(self)
Master.make_cake(self)
def make_school_cake(self):
# 父类类名.函数()
# 再次调用初始化的原因:这里想要调用父类的同名方法和属性,属性在init初始化位置,所以需要再次调用init进行初始化
School.__init__(self)
School.make_cake(self)
#3.用徒弟类创建对象,调用实例属性和方法
# daqiu = Prentice()
# print(daqiu.kongfu)
# daqiu.make_cake()
#
# daqiu.make_master_cake()
# daqiu.make_school_cake()
#
# daqiu.make_cake()
# print(Prentice.__mro__)
#结论:如果一个类继承多个父类,优先继承第一个弗雷德同名属性和方法
#总结:如果子类和父类拥有同名属性和方法,子类创建对象调用属性和方法的时候,调用到的是子类里面的同名属性和方法
#步骤:1.创建徒孙类Tusun,然后用这个类创建对象;2.用这个对象调用父类的属性或方法看能否成功
class Tusun(Prentice):
pass
xiaoqiu = Tusun()
xiaoqiu.make_cake()
xiaoqiu.make_school_cake()
xiaoqiu.make_master_cake()
运行结果:
302_super()方法作用
七、super()调用父类方法
#1.师父类,属性和方法
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#为了验证多继承,添加school父类
class School(object):
def __init__(self):
self.kongfu = '[黑马煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#2.定义徒弟类,继承师父类 和 学校类,添加和父类同名的属性和方法
class Prentice(School,Master):
def __init__(self):
self.kongfu = '[独创煎饼果子技术]'
def make_cake(self):
#此处加自己初始化的原因是:如果不加这个自己的初始化,kongfu属性值是上一次调用的init内的kongfu属性值
self.__init__()
print(f'运用{self.kongfu}制作煎饼果子')
#子类调用父类的同名方法和属性:把父类的同名属性和方法再次封装
def make_master_cake(self):
#父类类名.函数()
#再次调用初始化的原因:这里想要调用父类的同名方法和属性,属性在init初始化位置,所以需要再次调用init进行初始化
Master.__init__(self)
Master.make_cake(self)
def make_school_cake(self):
# 父类类名.函数()
# 再次调用初始化的原因:这里想要调用父类的同名方法和属性,属性在init初始化位置,所以需要再次调用init进行初始化
School.__init__(self)
School.make_cake(self)
#需求:一次性调用school类和master类两个父类的方法
def make_old_cake(self):
#方法一:如果定义的类名修改,这里也要跟着修改,麻烦;代码量庞大,冗余。
School.__init__(self)
School.make_cake(self)
Master.__init__(self)
Master.make_cake(self)
daqiu = Prentice()
daqiu.make_old_cake()
#3.用徒弟类创建对象,调用实例属性和方法
# daqiu = Prentice()
# print(daqiu.kongfu)
# daqiu.make_cake()
#
# daqiu.make_master_cake()
# daqiu.make_school_cake()
#
# daqiu.make_cake()
# print(Prentice.__mro__)
#结论:如果一个类继承多个父类,优先继承第一个弗雷德同名属性和方法
#总结:如果子类和父类拥有同名属性和方法,子类创建对象调用属性和方法的时候,调用到的是子类里面的同名属性和方法
#步骤:1.创建徒孙类Tusun,然后用这个类创建对象;2.用这个对象调用父类的属性或方法看能否成功
# class Tusun(Prentice):
# pass
#
# xiaoqiu = Tusun()
# xiaoqiu.make_cake()
# xiaoqiu.make_school_cake()
# xiaoqiu.make_master_cake()
运行结果:
303_super方法写法
带参数的super()方法调用父类的方法,代码实现如下所示:
#1.师父类,属性和方法
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#为了验证多继承,添加school父类
class School(Master):
def __init__(self):
self.kongfu = '[黑马煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#2.1 super()带参数写法
super(School,self).__init__()
super(School,self).make_cake()
#2.定义徒弟类,继承师父类 和 学校类,添加和父类同名的属性和方法
class Prentice(School):
def __init__(self):
self.kongfu = '[独创煎饼果子技术]'
def make_cake(self):
#此处加自己初始化的原因是:如果不加这个自己的初始化,kongfu属性值是上一次调用的init内的kongfu属性值
self.__init__()
print(f'运用{self.kongfu}制作煎饼果子')
#子类调用父类的同名方法和属性:把父类的同名属性和方法再次封装
def make_master_cake(self):
#父类类名.函数()
#再次调用初始化的原因:这里想要调用父类的同名方法和属性,属性在init初始化位置,所以需要再次调用init进行初始化
Master.__init__(self)
Master.make_cake(self)
def make_school_cake(self):
# 父类类名.函数()
# 再次调用初始化的原因:这里想要调用父类的同名方法和属性,属性在init初始化位置,所以需要再次调用init进行初始化
School.__init__(self)
School.make_cake(self)
#需求:一次性调用school类和master类两个父类的方法
def make_old_cake(self):
#方法一:如果定义的类名修改,这里也要跟着修改,麻烦;代码量庞大,冗余。
# School.__init__(self)
# School.make_cake(self)
# Master.__init__(self)
# Master.make_cake(self)
#方法二:super()
#2.1 super(当前类名,self).函数()
super(Prentice,self).__init__()
super(Prentice,self).make_cake()
daqiu = Prentice()
daqiu.make_old_cake()
运行结果:
不带参数的super()方法调用父类的方法,代码实现如下所示:
#1.师父类,属性和方法
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#为了验证多继承,添加school父类
class School(Master):
def __init__(self):
self.kongfu = '[黑马煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#2.1 super()带参数写法
#super(School,self).__init__()
#super(School,self).make_cake()
#2.2 无参数的super()
super().__init__()
super().make_cake()
#2.定义徒弟类,继承师父类 和 学校类,添加和父类同名的属性和方法
class Prentice(School):
def __init__(self):
self.kongfu = '[独创煎饼果子技术]'
def make_cake(self):
#此处加自己初始化的原因是:如果不加这个自己的初始化,kongfu属性值是上一次调用的init内的kongfu属性值
self.__init__()
print(f'运用{self.kongfu}制作煎饼果子')
#子类调用父类的同名方法和属性:把父类的同名属性和方法再次封装
def make_master_cake(self):
#父类类名.函数()
#再次调用初始化的原因:这里想要调用父类的同名方法和属性,属性在init初始化位置,所以需要再次调用init进行初始化
Master.__init__(self)
Master.make_cake(self)
def make_school_cake(self):
# 父类类名.函数()
# 再次调用初始化的原因:这里想要调用父类的同名方法和属性,属性在init初始化位置,所以需要再次调用init进行初始化
School.__init__(self)
School.make_cake(self)
#需求:一次性调用school类和master类两个父类的方法
def make_old_cake(self):
#方法一:如果定义的类名修改,这里也要跟着修改,麻烦;代码量庞大,冗余。
# School.__init__(self)
# School.make_cake(self)
# Master.__init__(self)
# Master.make_cake(self)
#方法二:super()
#2.1 super(当前类名,self).函数()
# super(Prentice,self).__init__()
# super(Prentice,self).make_cake()
#2.2 无参数的super().函数()
super().__init__()
super().make_cake()
daqiu = Prentice()
daqiu.make_old_cake()
#3.用徒弟类创建对象,调用实例属性和方法
# daqiu = Prentice()
# print(daqiu.kongfu)
# daqiu.make_cake()
#
# daqiu.make_master_cake()
# daqiu.make_school_cake()
#
# daqiu.make_cake()
# print(Prentice.__mro__)
#结论:如果一个类继承多个父类,优先继承第一个弗雷德同名属性和方法
#总结:如果子类和父类拥有同名属性和方法,子类创建对象调用属性和方法的时候,调用到的是子类里面的同名属性和方法
#步骤:1.创建徒孙类Tusun,然后用这个类创建对象;2.用这个对象调用父类的属性或方法看能否成功
# class Tusun(Prentice):
# pass
#
# xiaoqiu = Tusun()
# xiaoqiu.make_cake()
# xiaoqiu.make_school_cake()
# xiaoqiu.make_master_cake()
运行结果:
总结:使用super()可以自动查找父类。调用顺序遵循__mro__类属性的顺序。比较适合单继承使用。
304_定义私有属性和方法
八、私有权限
8.1 定义私有属性和方法
在python中,可以为实例属性和方法设置私有权限,即设置某个实例属性或实例方法不继承给子类。
故事:daqiu把技术传承给徒弟的同时,不想把自己的钱(20000个亿)继承给徒弟,这个时候就要为钱这个实例属性设置私有权限。
设置私有权限的方法:在属性名和方法名前面加上两个下划线__.
#1.师父类,属性和方法
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#为了验证多继承,添加school父类
class School(Master):
def __init__(self):
self.kongfu = '[黑马煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#2.1 super()带参数写法
#super(School,self).__init__()
#super(School,self).make_cake()
#2.2 无参数的super().函数()
super().__init__()
super().make_cake()
#2.定义徒弟类,继承师父类 和 学校类,添加和父类同名的属性和方法
class Prentice(School):
def __init__(self):
self.kongfu = '[独创煎饼果子技术]'
#self.money = 200000
#定义私有属性
#self.__money = 2000000 #此处的money为私有属性
#定义私有方法
def __info_print(self):
print('这是私有方法')#子类无法从父类那里继承的方法
def make_cake(self):
#此处加自己初始化的原因是:如果不加这个自己的初始化,kongfu属性值是上一次调用的init内的kongfu属性值
self.__init__()
print(f'运用{self.kongfu}制作煎饼果子')
#子类调用父类的同名方法和属性:把父类的同名属性和方法再次封装
def make_master_cake(self):
#父类类名.函数()
#再次调用初始化的原因:这里想要调用父类的同名方法和属性,属性在init初始化位置,所以需要再次调用init进行初始化
Master.__init__(self)
Master.make_cake(self)
def make_school_cake(self):
# 父类类名.函数()
# 再次调用初始化的原因:这里想要调用父类的同名方法和属性,属性在init初始化位置,所以需要再次调用init进行初始化
School.__init__(self)
School.make_cake(self)
#需求:一次性调用school类和master类两个父类的方法
def make_old_cake(self):
#方法一:如果定义的类名修改,这里也要跟着修改,麻烦;代码量庞大,冗余。
# School.__init__(self)
# School.make_cake(self)
# Master.__init__(self)
# Master.make_cake(self)
#方法二:super()
#2.1 super(当前类名,self).函数()
# super(Prentice,self).__init__()
# super(Prentice,self).make_cake()
#2.2 无参数的super().函数()
super().__init__()
super().make_cake()
daqiu = Prentice()
daqiu.make_old_cake()
#3.用徒弟类创建对象,调用实例属性和方法
# daqiu = Prentice()
# print(daqiu.kongfu)
# daqiu.make_cake()
#
# daqiu.make_master_cake()
# daqiu.make_school_cake()
#
# daqiu.make_cake()
# print(Prentice.__mro__)
#结论:如果一个类继承多个父类,优先继承第一个弗雷德同名属性和方法
#总结:如果子类和父类拥有同名属性和方法,子类创建对象调用属性和方法的时候,调用到的是子类里面的同名属性和方法
#步骤:1.创建徒孙类Tusun,然后用这个类创建对象;2.用这个对象调用父类的属性或方法看能否成功
class Tusun(Prentice):
pass
#
xiaoqiu = Tusun()
#print(xiaoqiu.money)
xiaoqiu.info_print()
# xiaoqiu.make_cake()
# xiaoqiu.make_school_cake()
# xiaoqiu.make_master_cake()
运行结果:
注意:私有属性和私有方法只能在类里面访问和修改。
305_获取和修改私有属性值
8.2 获取和修改私有属性值
在Python中,一般定义函数名get_xx用来获取私有属性,定义set_xx用来修改私有属性值。
#1.师父类,属性和方法
class Master(object):
def __init__(self):
self.kongfu = '[古法煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#为了验证多继承,添加school父类
class School(Master):
def __init__(self):
self.kongfu = '[黑马煎饼果子配方]'
def make_cake(self):
print(f'运用{self.kongfu}制作煎饼果子')
#2.1 super()带参数写法
#super(School,self).__init__()
#super(School,self).make_cake()
#2.2 无参数的super().函数()
super().__init__()
super().make_cake()
#2.定义徒弟类,继承师父类 和 学校类,添加和父类同名的属性和方法
class Prentice(School):
def __init__(self):
self.kongfu = '[独创煎饼果子技术]'
#self.money = 200000
#定义私有属性
self.__money = 2000000 #此处的money为私有属性
#定义函数:获取私有属性值 get_xx
def get_money(self):
return self.__money
#定义函数:修改私有属性值 set_xx
def set_money(self):
self.__money = 500
#定义私有方法
def __info_print(self):
print('这是私有方法')#子类无法从父类那里继承的方法
def make_cake(self):
#此处加自己初始化的原因是:如果不加这个自己的初始化,kongfu属性值是上一次调用的init内的kongfu属性值
self.__init__()
print(f'运用{self.kongfu}制作煎饼果子')
#子类调用父类的同名方法和属性:把父类的同名属性和方法再次封装
def make_master_cake(self):
#父类类名.函数()
#再次调用初始化的原因:这里想要调用父类的同名方法和属性,属性在init初始化位置,所以需要再次调用init进行初始化
Master.__init__(self)
Master.make_cake(self)
def make_school_cake(self):
# 父类类名.函数()
# 再次调用初始化的原因:这里想要调用父类的同名方法和属性,属性在init初始化位置,所以需要再次调用init进行初始化
School.__init__(self)
School.make_cake(self)
#需求:一次性调用school类和master类两个父类的方法
def make_old_cake(self):
#方法一:如果定义的类名修改,这里也要跟着修改,麻烦;代码量庞大,冗余。
# School.__init__(self)
# School.make_cake(self)
# Master.__init__(self)
# Master.make_cake(self)
#方法二:super()
#2.1 super(当前类名,self).函数()
# super(Prentice,self).__init__()
# super(Prentice,self).make_cake()
#2.2 无参数的super().函数()
super().__init__()
super().make_cake()
daqiu = Prentice()
daqiu.make_old_cake()
#3.用徒弟类创建对象,调用实例属性和方法
# daqiu = Prentice()
# print(daqiu.kongfu)
# daqiu.make_cake()
#
# daqiu.make_master_cake()
# daqiu.make_school_cake()
#
# daqiu.make_cake()
# print(Prentice.__mro__)
#结论:如果一个类继承多个父类,优先继承第一个弗雷德同名属性和方法
#总结:如果子类和父类拥有同名属性和方法,子类创建对象调用属性和方法的时候,调用到的是子类里面的同名属性和方法
#步骤:1.创建徒孙类Tusun,然后用这个类创建对象;2.用这个对象调用父类的属性或方法看能否成功
class Tusun(Prentice):
pass
#
xiaoqiu = Tusun()
print(xiaoqiu.get_money())
xiaoqiu.set_money()
print(xiaoqiu.get_money())
#xiaoqiu.info_print()
# xiaoqiu.make_cake()
# xiaoqiu.make_school_cake()
# xiaoqiu.make_master_cake()
运行结果:
306_继承总结
九、总结
- 继承的特点
- 子类默认拥有父类的所有属性和方法
- 子类重写父类同名方法和属性
- 子类调用父类同名方法和属性
- super()方法快速调用父类方法
- 私有权限
- 不能继承给子类的属性和方法需要添加私有权限
- 语法
class 类名()
#私有属性
__属性名 = 值
#私有方法
def __函数名(self):
代码