面向对象语言的三大特征: 封装 继承 多态(二)——继承

举报
诡途 发表于 2021/11/19 00:38:53 2021/11/19
【摘要】 文章目录 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

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

举报
请填写举报理由
0/200