1. 继承

• 什么是继承
  -- 继承是一种创建新的类的方式；
  -- 新创建的叫子类；
  -- 被继承的叫父类、超类、基类；
• 示例：

>>> class Animal():                 # 创建一个父类 Animal 
...     def __init__(self):
...         print("this is an animal")
...     def swim(self):             # 创建 swim 方法
...         print("animal swim")
...
>>> class Cat(Animal):              # 创建一个子类 Cat，继承自 Animal 父类 
...     def __init__(self):
...         super().__init__()      # 使用 super().__init__() 继承 Animal 父类的所有方法，包括__init__ 方法和 swim 方法
...     def walk(self):             # 创建 walk 方法，该方法在 Cat 子类内部创建，与 Animal 父类无关 
...         print("cat walk")
...
>>> cat = Cat()                     # 实例化 Cat 子类
this is an animal                   # Cat 子类继承了 Animal 父类的所有属性和方法，所以才会打印 this is an animal
>>> cat.walk()                      # cat 实力调用 Cat 子类独有的 walk 方法
cat walk
>>> cat.swim()                      # 注意：cat 实例可以调用 Animal 父类的 swim 方法，而这个方法 Cat 子类中并未创建 
animal swim

-- 在上面的代码中，Cat 就是子类，Animal 就是父类，Cat 继承了 Animal 的 【全部】 属性和方法；
-- Cat 子类继承了 Animal 父类的 __ init __() 方法，所以在用 cat 对 Cat 类进行实例化时，才会打印 this is an animal；
-- Cat 子类继承了 Animal 父类的 swim() 方法，所以尽管 Cat 子类中没有 swim() 方法，但是 Cat 的实例 cat 仍然可以调用 swim() 方法；

• 继承的缺陷：
  -- 如上面的代码，Cat 子类中没有 swim() 方法，因为猫不会游泳，但是 Cat 子类继承自 Animal父类，Cat 子类的实例 cat 仍然可以调用 swim() 方法，这其实存在巨大的隐患；
  -- 实际上在生产环境中，我们并不希望 Cat 子类继承 Animal 父类的 swim() 方法，这种情形会导致可能会导致 bug；
  -- 由于 swim() 这类本不该继承的方法的存在，继承关系会变得混乱而复杂，不利于问题的溯源。
• 继承的作用
  -- 子类可以使用父类的属性（特征、方法）；
  -- 减少代码冗余、提高重用性。

2. 单继承

• 什么是单继承
  -- 单继承，一个类只能继承一个父类的继承方式；
• 示例：

>>> class Animal():                        # 创建父类 Animal
...     def __init__(self):                # 初始化，打印 this is an animal
...         print("this is an animal")
...     def swim(self):
...         print("animal swim")
...     def walk(self):
...         print("animal walk")
...     def fly(self):
...         print("animal fly")
...
>>>
>>> class Cat(Animal):
...     def walk(self):                     # 重写 walk 方法
...         print("cat walk")
...
>>>
>>> class Fish(Animal):
...     def swim(self):                    # 重写 swim 方法
...         print("fish swim")
...
>>>
>>> class Bird(Animal):
...     def swim(self):                    # 重写 swim 方法
...         print("bird swim")
...     def walk(self):                    # 重写 walk 方法
...         print("bird walk")
...     def fly(self):                     # 重写 fly方法
...         print("bird fly")
...
>>>
>>> white_cat = Cat()
this is an animal                          # 实例化 Cat 类时，打印 this is an animal，这是继承自 Animal 父类的初始化动作
>>> white_cat.walk()
cat walk
>>>
>>>
>>> golden_fish = Fish()
this is an animal                          # 实例化 Fish 类时，打印 this is an animal，这是继承自 Animal 父类的初始化动作
>>> golden_fish.swim()
fish swim
>>>
>>>
>>> blue_bird = Bird()
this is an animal                          # 实例化 Bird 类时，打印 this is an animal，这是继承自 Animal 父类的初始化动作
>>> blue_bird.walk()
bird walk
>>> blue_bird.swim()
bird swim
>>> blue_bird.fly()
bird fly

• 单继承缺陷：
  -- Cat、Fish、Bird 三个子类继承自 Animal 父类，需要重写各自调用的方法，重写方法使得代码重复、臃肿；
  -- Animal 父类中的方法比较多，总共有三个方法，但是其子类并未全部继承，而且由于没有严格的规则定义什么类型的子类继承父类中的那个方法，导致继承关系比较散乱，结构不够严谨、不利于整体的管理；

3. 多继承

• 什么是多继承
  -- 多继承，一个类可以继承多个父类的继承方式；
• 示例，上面的代码可以改成如下：

>>> class Animal():
...     def __init__(self):
...         print("this is an animal")
...
>>> class SwimAnimal(Animal):
...     def __init__(self):
...         super().__init__()
...         print("this is swim animal")
...     def swim(self):
...         print("animal swim")
...
>>>
>>> class WalkAnimal(Animal):
...     def __init__(self):
...         super().__init__()
...         print("this is walk animal")
...     def walk(self):
...         print("animal walk")
...
>>>
>>> class FlyAnimal(Animal):
...     def __init__(self):
...         super().__init__()
...         print("this is fly animal")
...     def fly(self):
...         print("animal fly")
...
>>>
>>> class Cat(WalkAnimal):
...     def __init__(self):
...         super().__init__()
...
>>>
>>> class Fish(SwimAnimal):
...     def __init__(self):
...         super().__init__()
...
>>>
>>> class Bird(SwimAnimal, WalkAnimal, FlyAnimal):
...     def __init__(self):
...         super().__init__()
...
>>>
>>> white_cat = Cat()
this is an animal
this is walk animal
>>> white_cat.walk()
animal walk
>>>
>>>
>>> golden_fish = Fish()
this is an animal
this is swim animal
>>> golden_fish.swim()
animal swim
>>>
>>>
>>> blue_bird = Bird()
this is an animal
this is fly animal
this is walk animal
this is swim animal
>>> blue_bird.walk()
animal walk
>>> blue_bird.swim()
animal swim
>>> blue_bird.fly()
animal fly

-- 上面的代码中，SwimAnimal、WalkAnimal、FlyAnimal 三个类继承自 Animal 父类，Cat 类继承自 WalkAnimal，Fish 类继承自 SwimAnimal，Bird 类继承自 SwimAnimal, WalkAnimal, FlyAnimal 三个类；
-- 图示如下：

image.png

-- 其中，Bird 类继承自 SwimAnimal, WalkAnimal, FlyAnimal 三个类，而这三个类又共同继承自 Animal 父类，所以实例化 Bird 类时，打印了 this is an animal、this is fly animal、this is walk animal、this is swim animal 四句话；

• 多继承优点：
  -- 使用多继承，可以使得继承关系更加清晰，代码结构构架严谨、整洁，更易于代码设计和管理；
  -- 使用多继承，在遇到报错时可以更容易通过继承关系进行问题定位，代码可维护性会更高；