当前位置 博文首页 > Python 面向对象编程的三大特性之继承

    Python 面向对象编程的三大特性之继承

    作者:小菠萝的测试笔记 时间:2021-09-15 18:20

    目录
    • Python  面向对象编程的三大特性之继承
      • 一、继承
        • 1、继承的实际栗子
        • 2、继承的好处
        • 3、继承的使用场景
        • 4、继承有几种?
        • 5、Python 中继承的简单语法
      • 二、不使用继承、使用继承的区别
        • 1、需求背景
        • 2、不使用继承
        • 2、使用继承
      • 三、继承的传递性
        • 1、什么是传递性
      • 四、继承和抽象
        • 1、继承的重点

    Python  面向对象编程的三大特性之继承

    一、继承

    • 继承也是面向对象编程三大特性之一
    • 继承是类与类的一种关系
    • 定义一个新的 class 时,可以从某个现有的 class 继承
    • 新的 class 类就叫子类(Subclass
    • 被继承的类一般称为父类基类超类
    • 通俗理解:子类与父类的关系,即爸爸与儿子,爸爸有了个儿子,儿子继承爸爸的属性和方法,爸爸的爸爸就是爷爷...以此类推

    1、继承的实际栗子

    • 猫、狗都是动物,所以动物是父类猫、狗是动物的子类
    • 小菠萝、大菠萝都是人类,所以人类是父类,小菠萝、大菠萝是人类的子类
    • 动物、人类都是生物,所以生物是父类,动物、人类是生物的子类
    • 那么一般称生物类是猫、狗、小菠萝、大菠萝的超类、祖父类

    2、继承的好处

    • 实现代码的重用,相同的代码不需要重复编写
    • 子类拥有父类的所有属性、方法,提高了代码的可扩展性和重用性
    • 在子类继承父类的同时,也可以重新定义某些属性,并重写某些方法,即覆盖父类的属性、方法,变成子类独有的属性、方法
    • 子类也可以添加新的属性、方法

    3、继承的使用场景

    • 假如我需要定义几个类,而类与类之间有一些公共的属性和方法
    • 可以把公共的属性和方法提取作为父类(基类)的属性、方法,而特殊的属性、方法则在本类中定义
    • 比如猫、狗都有吃喝拉撒四种行为,这些就是公共方法;但只有猫会喵喵叫,只有狗会汪汪叫,这些就是特殊方法

    具体可以看下面的【不使用继承、使用继承的区别】

    4、继承有几种?

    单继承
    多继承

    5、Python 中继承的简单语法

    class Parent:
        pass
    
    class Child(Parent):
        pass
    
    

    有个重点:

    所有类的都有一个共同父类,就是 object,默认会继承它,写或不写都一样

    class Parent:
        pass
    
    class Parent(object):
        pass
    
    

    二、不使用继承、使用继承的区别

    1、需求背景

    有一个动物类、狗类、猫类

    • 动物类有吃、喝、跑方法
    • 狗类有吃、喝、跑、汪汪叫方法
    • 猫类有吃、喝、跑、喵喵叫方法

    2、不使用继承

    类图

    需求分析

    • 每个类都拥有自己的方法
    • 他们都拥有吃、喝、拉方法,且功能一样

    实际代码:

    # 不使用继承
    class Animal:
        def eat(self):
            print("吃东西...")
    
        def drink(self):
            print("喝水...")
    
        def run(self):
            print("跑步...")
    
    
    class Cat:
        def eat(self):
            print("吃东西...")
    
        def drink(self):
            print("喝水...")
    
        def run(self):
            print("跑步...")
    
        def miao(self):
            print("喵喵叫...")
    
    
    class Dog:
        def eat(self):
            print("吃东西...")
    
        def drink(self):
            print("喝水...")
    
        def run(self):
            print("跑步...")
    
        def wang(self):
            print("汪汪叫...")
     
    
    

    这样写有什么问题?

    • 三个类,需要重复写三次吃、喝、跑的方法
    • 假设此时需要修改 吃 方法的代码,那么还得同步修改三个类的 吃 方法,属于不必要的重复性工作
    • 使用继承可以大大减少开发工作量

    2、使用继承

    类图

    从类图就能看到,使用继承就变得简单多了

    需求分析

    • 提取三个类的公共方法,吃、喝、跑,然后抽象成动物类
    • 所以动物类是一个父类,狗类、猫类继承它

    实际代码:

    # 使用继承
    class Animal:
        def eat(self):
            print("吃东西...")
    
        def drink(self):
            print("喝水...")
    
        def run(self):
            print("跑步...")
    
    
    class Cat(Animal):
        def miao(self):
            print("喵喵叫...")
    
    
    class Dog(Animal):
        def wang(self):
            print("汪汪叫...")
     
    
    

    优势:

    • 子类继承父类,可以直接享受父类已经封装好的方法,不再需要自己开发一次
    • 子类可以根据自身的需要,封装子类独有的属性、方法,比如猫类的喵喵叫,狗类的汪汪叫 

    专业术语总结

    • Dog 类是 Animale 类的子类,Animal 类是 Dog 类的父类,Dog 类从 Animal 类继承
    • Dog 类是 Animale 类的派生类,Animal 类是 Dog 类的基类,Dog 类从 Animal 类派生

    三、继承的传递性

    1、什么是传递性

    通俗来讲

    • C 类从 B 类继承,B 类又从 A 类继承
    • 那么 C 类会拥有 A、B 类的所有属性和方法 

    官方来讲

    • 子类拥有父类以及父类的父类,以及所有父类的父类的父类...中封装的所有属性、方法

    实际栗子:

    • 还是拿上面的动物类、狗类、猫类继续展开讲
    • 假设此时有一个新的类叫柴犬类,继承于狗类,有独有的方法摇尾巴

    类图

    实际代码:

    class Animal:
        def eat(self):
            print("吃东西...")
    
        def drink(self):
            print("喝水...")
    
        def run(self):
            print("跑步...")
    
    
    class Cat(Animal):
        def miao(self):
            print("喵喵叫...")
    
    
    class Dog(Animal):
        def wang(self):
            print("汪汪叫...")
    
    
    class Chai(Dog):
        def shake(self):
            print("小柴柴摇尾巴...")
    
    
    chai = Chai()
    # 调用 父类的父类 的方法
    chai.eat()
    # 调用 父类 的方法
    chai.wang()
    # 调用 自己独有 的方法
    chai.shake()
    
    
    # 输出结果
    吃东西...
    汪汪叫...
    小柴柴摇尾巴...
    
    
    
    • Chai 类拥有 Dog 类、Animal 类所有属性、方法
    • 但它不会拥有 Cat 类的属性、方法,因为他们没有继承关系

    四、继承和抽象

    抽象即抽取类似或者说比较像的部分

    小栗子:

    • 从小菠萝、小韵韵两个对象中,抽取公共部分抽象成父类
    • 再从人,猪,狗这三个类,抽取公共部分抽象成父类

    1、继承的重点

    • 是基于抽象的结果,通过编程语言去实现它
    • 先经历抽象这个过程,才能通过继承的方式去表达出抽象的结构
    • 抽象只是分析和设计的过程中,一个动作或者说一个技巧,通过抽象得到一个类

    代码栗子:

    class Animal:
        def __init__(self, name, age, sex):
            self.__name = name
            self.__age = age
            self.__sex = sex
    
        # 提取的公共方法
        def eat(self):
            print(f"{self.__name} 正在吃饭....")
    
        @property
        def name(self):
            return self.__name
    
    
    class Person(Animal):
        def walk(self):
            print(f"{self.name} 两条腿正在走路")
    
    
    class Pig(Animal):
        def kill(self):
            print(f"{self.name} 猪正在去屠宰场ing...")
    
    
    class Dog(Animal):
        def wang(self):
            print(f"{self.name} 汪汪叫ing...")
    
    
    person = Person("小菠萝", 25, "Male")
    pig = Pig("麦兜", 4, "公")
    dog = Dog("柴犬", 3, "母")
    
    # 调用父类的公共方法
    person.eat()
    pig.eat()
    dog.eat()
    
    # 调用子类独有的方法
    person.walk()
    pig.kill()
    dog.wang()
    
     
    
    # 输出结果
    小菠萝 正在吃饭....
    麦兜 正在吃饭....
    柴犬 正在吃饭....
    
    小菠萝 两条腿正在走路
    麦兜 猪正在去屠宰场ing...
    柴犬 汪汪叫ing...
    
    jsjbwy