Python_从零开始学习_(39) 继承

小灰灰 2021-09-16 17:54 453阅读 0赞

**目录**

1.  单继承

1.1  继承的概念,  语法和特点

1.2  方法的重写

1.3  父类的 私有属性 和 私有方法

2.  多继承

2.1  多继承的使用注意事项

2.2  新式类与旧式 (经典) 类

--------------------

目标

--------------------

*  单继承
 *  多继承

**面向对象三大特性**

1.  **封装 **根据 **职责 **将 **属性 **和 **方法 封装 **到一个抽象的 **类 中**
2.  **继承 实现代码的重用, **相同的代码不需要重复的编写
3.  **多态 **不同的对象调用相同的方法,  产生不同的执行结果,  **增加代码的灵活度**

## **1.  单继承** ##

--------------------

### **1.1  继承的概念,  语法和特点** ###

**继承的概念:  子类 **拥有 **父类 **的所有 **方法 **和 **属性**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5kYW4xMTI3_size_27_color_FFFFFF_t_70][]

**1)  继承的语法 **

class 类名(父类名):
    
        pass

*  **子类 **继承自 **父亲,  **可以直接 **享受 **父类中已经封装好的方法,  不需要再次开发
 *  **子类 **中应该根据 **职责,  **封装 **子类特有的 属性和方法**

**2)  专业术语**

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

**3)  继承的传递性**

*  C 类从 B 类继承,  B 类又从 A 类继承
 *  那么 C 类就具有 B 类和 A 类的所有属性和方法

**子类** 拥有 **父类** 以及 **父类的父类** 中封装的所有 **属性** 和 **方法** (儿子有父亲和爷爷的所有特点)

class Animal:
    
        def eat(self):
            print("吃")
    
        def drink(self):
            print("喝")
    
        def run(self):
            print("跑")
    
        def sleep(self):
            print("睡")
    
    
    class Dog(Animal):
    
        def bark(self):
            print("叫")
    
    
    class XiaoTianQuan(Dog):
    
        def fly(self):
            print("I can fly")
    
    
    xtq = XiaoTianQuan()
    xtq.run()
    xtq.bark()
    xtq.fly()

### 1.2  方法的重写 ###

*  **子类 **拥有 **父类 **的所有 **方法 **和 **属性**
 *  **子类 **继承自 **父类,  **可以直接 **享受 **父类中已经封装好的方法,  不需要再次开发

应用场景

*  当 **父类 **的方法实现不能满足子类需求时,  可以对方法进行 **重新(voerwrite)**

**重新 **父类方法有两种情况:

1.  **覆盖 **父类的方法
2.  对父类方法进行 **扩展**

**1)  覆盖父类的方法**

*  如果在开发中,  **父类的方法实现 **和 **子类的方法实现, 完全不同**
 *  就可以使用 **覆盖 **的方式,  **在子类中 重新编写 **父类的方法实现

> 具体的实现方式,  就相当于在 **子类中 **定义了一个 **和父类同名的方法并且实现**

重写之后,  在运行时,  **只会调用 **子类中重写的方法,  而不再回调用 **父类封装的方法**

**2)  对父类方法进行 扩展**

*  如果在开发中,  **子类的方法实现 **中 **包含 父类的方法实现**
 *  **父类 原本封装的方法实现 **是 **子类方法的一部分**
 *  就可以使用 **扩展 **的方式

1.  **在子类中 重写** 父类的方法
2.  在需要的位置使用 super( ), 父类方法 来调用父类方法的执行
3.  代码其他的位置针对子类的需求, 编写 **子类特有的代码实现**

**关于 super**

*  在 Python 中 super 是一个 **特殊的类**
 *  super() 就是使用 super 类创建出来的对象
 *  **最常 **使用的场景就是在 **重写父类方法时,  **调用 **父类中封装的方法实现**

class XiaoTianQuan(Dog):
    
        def fly(self):
            print("I can fly")
    
        def bark(self):
    
            # 1. 针对子类特有的需求, 编写代码
            print("嗷呜....")
    
            # 2. 使用super(), 调用原本在父类中的封装的方法
            super().bark()
    
            # 3. 增加其他子类的代码
            print("嗷呜嗷呜...")

### 1.3  父类的 私有属性 和 私有方法 ###

1.  **子类对象** **不能** 在自己的方法内部, **直接** 访问 父类的 **私有属性** 或 **私有方法**
2.  **子类对象** 可以通过 父类 的 **公有方法 间接** 访问到 **私有属性** 或 **私有方法**

>  *  **私有属性, 方法 **是对象的隐私,  不对外公开,  **外界 **以及 **子类 **都不能直接访问
>  *  **私有属性, 方法 **通常用于做一些内部的事情

*  B 的对象不能直接访问 \_\_num2 属性
 *  B 的对象不能再 demo 方法内访问 \_\_num2 属性
 *  B 的对象可以在 demo 方法内, 调用父类的 test 方法
 *  父类的 test 方法内部,  能够访问 \_\_num2 属性和 \_\_test 方法

class A:
    
        def __init__(self):
    
            self.num1 = 100
            self.__num2 = 200
    
        def __test(self):
            print("私有方法 %d %d" % (self.num1, self.__num2))
    
        def test(self):
            print("父类的公有方法 %d" % self.__num2)
    
            self.__test()
    
    
    class B(A):
    
        def demo(self):
    
            # 1. 在子类的对象方法中, 不能访问父类的私有属性
            # print("访问父类的私有属性 %d" % self.__num2)
    
            # 2. 在子类的对象方法中, 不能访问父类的私有方法
            # self.__test()
    
            # 3. 访问父类的公有属性
            print("子类方法 %d" % self.num1)
    
            # 4. 访问父类的公有方法
            self.test()
    
    
    b = B()
    print(b)
    
    b.demo()
    # print(b.num1)
    # b.test()
    
    # 在外界不能直接访问对象的私有属性和私有方法
    # print(b.__num2)
    # print(b.__test)

## 2.  多继承 ##

--------------------

概念

*  **子类** 可以拥有 **多个父类, ** 并且具有 **所有父类** 的 **属性** 和 **方法**
 *  例如: **孩子** 会继承自己 **父亲** 和 **母亲** 的 **特性**

语法

class 子类名(父类名1, 父类名2...):
        pass

### 2.1  多继承的使用注意事项 ###

问题的提出

*  如果 **不同的父类 **中存在 **同名的方法,  子类对象 **在调用方法时,  会调用 **哪一个父类中**的方法呢?

> 提示 : **开发时,  应该尽量避免这种容易产生混淆的情况! ** \---- 如果 **父类之间 **存在 **同名的属性或者方法,  **应该 **尽量避免 **使用多继承

例如 :

class A:
    
        def test(self):
            print("父类A")
    
    
    class B:
    
        def test(self):
            print("父类B")
    
    
    class C(A, B):
        """多继承可以让子类对象, 同时具有多个父类的属性和方法"""
        pass
    
    
    # 创建子类
    c = C()
    c.test()

**Python 中的 MRO ---- 方法搜索顺序 (科普)**

*  Python 中针对 类 提供了一个 内置属性 \_\_mro\_\_ 可以查看 方法 搜索顺序
 *  MRO 是 method resolution order , 主要用于 在多继承时判断 方法, 属性, 的调用 路径

print(C.__mro__)

输出结果

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

*  在搜索方法时,  是按照 \_\_mro\_\_的输出结果 **从左至右** 的顺序查找的
 *  如果在当前类中 **找到方法,  就直接执行,  不再搜索**
 *  如果 **没有找到, 就查找下一个类** 中是否有对应的方法,  **如果找到,  就直接执行,  不再搜索**
 *  如果找到最后一个类,  还没找到方法,  程序报错

### 2.2  新式类与旧式 (经典) 类 ###

> object 是 Python 为所有对象提供的 **基类**,  提供有一些内置的属性和方法,  可以使用 dir 函数查看

*  **新式类** :  以 object 为基类的类,  **推荐使用**
 *  **经典类** :  不以 object 为基类的类,  **不推荐使用**
 *  在 Python 3.x 中定义类时,  如果没有指定父类,  会 **默认使用** object 作为该类的 **基类**  ----  Python 3.x 中定义的类都是 **新式类**
 *  在 Python 2.x 中定义类时,  如果没有指定父类,  则不会以 object 作为 **基类**

> **新式类 和 经典类 在多继承时 ---- 会影响到方法的搜索顺序**

为了保证保证编写的代码能够同时在 Python 2.x 和 Python 3.x 运行!

今后在定义类时,  如果没有父类,  建议统一继承自 object

class 类名(object):
        pass

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppYW5kYW4xMTI3_size_27_color_FFFFFF_t_70]: /images/20210726/2f69b0477d2a42b2b551ab0c0c220a0d.png