面向对象语言的三大特征: 封装 继承 多态（二）——继承
【摘要】
文章目录
1.什么是继承？2.继承中的概念3.方法的重写
1.什么是继承？
在程序中:
由两个或者多个相关类中提取共性 ，将共性存放于一个共通类中，通过指定方式有普通类与共通类关联起来,...
1.什么是继承？
在程序中:
- 由两个或者多个相关类中提取共性 ，将共性存放于一个共通类中，通过指定方式有普通类与共通类关联起来,形成继承体系
- 共通类: 称为父类 / 超类 / 基类；普通类: 称为子类
- 父类和子类的关系：子类
继承自父类；父类派生出子类
继承的伪代码
#父类
class 父类类名:
def __init__(self,形参列表):
子类中的共同特征
子类中的共同行为
#子类
class 子类类名(父类类名):
def __init__(self, 共性字段列表, 个性字段的列表):
#调用父类的位共性字段初始化的方式
#为个性字段初始化赋值
个性方法
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
案例:
类似于高中数学学的归纳法，归纳出通项
各个子类又具有自己独有特征
class Person:
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
def eat(self):
print(self.name, '吃饭')
class Student(Person):
# 初始化学生对象时，不仅需要对个性赋值，还需要给共性赋值
def __init__(self, name, age, sex, sid):
# 需要调用父类中的为共性赋值的初始化方法
"""
super --- 表示的是父类 Person
self --- 表示的是当前类的对象
super(): 创建一个父类对象
创建对象的格式: 类名()
"""
super().__init__(name, age, sex)
# 为个性赋值
self.sid = sid
# 个性行为
def study(self):
# 需要使用父类中的字段 因为是继承关系 就像使用自己的一样 直接使用就行
print(self.name, "在学习")
class worker(Person):
def __init__(self, name, age, sex, wid):
super().__init__(name, age, sex)
self.wid = wid
def work(self):
print(self.name, "在工作")
def main():
# 创建对象
stu = Student("诡途", 18, "男", '0010')
stu.eat() # 父类方法
stu.study() # 子类方法
# 创建对象
wk = worker("天猫精灵", 20, "女", "1234")
wk.eat()
wk.work()
if __name__ == '__main__':
main()
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
class Animal:
def __init__(self, name, age, sex):
self.__name = name
self.__age = age
self.__sex = sex
@property
def name(self):
return self.__name
# 这里的name是下面的set的name
@name.setter
def name(self, name):
self.__name = name
@property
def age(self):
return self.__age
@age.setter
def age(self, age):
if age < 0:
self.__age = 0
else:
self.__age = age
@property
def sex(self):
return self.__sex
@sex.setter
def sex(self, sex):
if sex != "雌" and sex != "雄":
self.__sex = "雌"
else:
self.__sex = sex
"""
父类中的共性特征都私有化了：
凡是私有化的内容的作用范围：仅限于当前类中，即使子类也无权访问
子类如果想访问，——使用父类提供的访问方式进行访问
如同子类还想通过普通的访问格式进行访问
需要把父类中的方法属性化才可以
"""
class Dog(Animal):
def __init__(self, name, age, sex, breed):
super().__init__(name, age, sex)
self.bred = breed
def eat_bone(self):
print(self.name, "啃骨头")
def look_home(self):
print(self.name, "看家")
class Cat(Animal):
def __init__(self, name, age, sex):
super().__init__(name, age, sex)
def eat_fish(self):
print(self.name, "吃鱼")
def catch_mouse(self):
print(self.name, "抓老鼠")
def main():
cat = Cat("ketty", age=2, sex="雌")
cat.eat_fish()
print(cat.name, cat.sex)
if __name__ == '__main__':
main()
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
2.继承中的概念
-
单继承: 一个类有且仅有一个父类
-
多重继承/多层继承: 一个类可以间接继承多个父类
-
多继承: 一个类可以有多个父类 [Python支持多继承]，class 子类(父类1, 父类2, … )
多层继承关系：子类 - 父类 - 爷爷类 – 老爷爷类
间接继承也可以直接使用共性的
#通过动物体系演示概念
#狗 : dog、蝙蝠: bat、鹦鹉: parrot、鸵鸟: ostrich、
Animal 顶级类
哺乳类Mammal和鸟类Bird 次级顶类
哺乳类: 狗 蝙蝠
鸟类: 鹦鹉 鸵鸟
能跑的runnable 和 能飞的flyable
runnable:狗 鹦鹉 鸵鸟
flyable:蝙蝠 鹦鹉
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
class Animal:
pass
class Runnable:
pass
class Flyable:
pass
# 哺乳类
class Mammal(Animal):
pass
class Bird(Animal):
pass
class Dog(Mammal, Runnable):
pass
class Parrot(Bird, Flyable):
pass
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
Python支持多继承,C++也支持多继承，Java只能单继承
#查看类的父类
类名.__bases__
# 查看Student的父类
print(Student.__bases__)
>>> (<class '__main__.Person'>,)
# 查看Person 的父类
print(Person.__bases__)
>>>(<class 'object'>,)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
object根类：
- object类：根类 – 族谱中的老祖宗
- 所有的类都是object的直接子类或者间接子类
- 没有标注继承自谁, 默认就是继承自object
3.方法的重写
子类去重写父类中的方法，
当子类重写了父类中的方法，子类再调用该方法时 调用的是子类重写之后的
什么时候进行重写？
- 子类中该功能的实现 父类无法满足了 子类就可以对其进行重写
重写类型
- 自定义方法重写
- 系统方法重写。
class Bird:
def __init__(self, color):
self.color = color
'''
鸟类 攻击行为
小红鸟 --- 死撞
小黑鸟 --- 爆炸
小黄鸟 --- 加速
小蓝鸟 --- 分裂
'''
def attach(self):
print("父类中的攻击实现")
class RedBird(Bird):
def __init__(self, color):
super().__init__(color)
# 攻击行为: 子类中的方法声明与父类中的方法声明一致 实现功能的内容部分可以不一样
def attach(self):
# 当子类重写了父类中的方法，子类再调用该方法时 调用的是子类重写之后的
# 子类重写之后 还想实现父类中方法的功能 可以在子类重写的方法中 通过super去调用
super().attach()
print("死撞")
def main():
rb = RedBird("红色")
rb.attach()
if __name__ == "__main__":
main()
>>>父类中的攻击实现 #实现父类方法
>>>死撞 #实现子类中重写方法
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
文章来源: blog.csdn.net，作者：诡途，版权归原作者所有，如需转载，请联系作者。
原文链接：blog.csdn.net/qq_35866846/article/details/108238271
【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）