[面向对象之继承应用（在子类派生重用父类功能（super），继承实现原理（继承顺序、菱形问题、继承原理、Mixins机制），组合]

[面向对象之继承应用（在子类派生重用父类功能（super），继承实现原理（继承顺序、菱形问题、继承原理、Mixins机制），组合]

---

继承应用

类与类之间的继承指的是什么’是’什么的关系（比如人类，猪类，猴类都是动物类）。子类可以继承／遗传父类所有的属性，因而继承可以用来解决类与类之间的代码重用性问题。比如我们按照定义Student类的方式再定义一个Teacher类

class Student:           # 定义学生类
    school = "虹桥校区"   # 冗余共同属性

    def __init__(self,name,age,gender):  # 学生类与老师类有冗余部分
        self.name = name
        self.age = age
        self.gender = gender

    def choose(self):
        print("%s 选课成功" %self.name)

stu1 = Student("jack",18,"male")
stu2 = Student("tom",19,"male")
stu3 = Student('lili',29,"female")

class Teacher:          # 定义老师类
    school = "虹桥校区"

    def __init__(self,name,age,gender,level):  # 老师类与学生类功能多一个level
        self.name = name
        self.age = age
        self.gender = gender
        self.level = level

    def score(self):
        print("%s 正在为学生打分" %self.name)

tea1 = Teacher('egon',18,"male",10)
tea2 = Teacher('lxx',38,"male",3)

从上面看出：类Teacher与Student之间存在重复的代码，老师与学生都是人类，所以我们可以得出如下继承关系，实现代码重用

• 在子类派生的新方法中重用父类的功能：

• 方式一: 指名道姓地引用某一个类的函数，与继承无关

class People:
    school = "虹桥校区"    # 将冗余数据放到父类当中

    def __init__(self,name,age,gender):  # 将学生类和老师类的共同属性放到父类中间解决冗余问题
        self.name = name
        self.age = age
        self.gender = gender

class Student(People):
    def choose(self):
        print("%s 选课成功" %self.name)

class Teacher(People):
         #      定义一个__init__函数是形参
	 #      空对象,'egon',18,"male",10
    def __init__(self,name,age,gender,level):  # 老师类多一个level就需要保留
   # 调用父类的__init__是函数（实参）不是方法，为老师类的__init__进行传参
        People.__init__(self,name,age,gender)  # 在子类的派生当中重用父类功能

        self.level = level

    def score(self):
        print("%s 正在为学生打分" %self.name)

stu1 = Student("jack",18,"male")
stu2 = Student("tom",19,"male")
stu3 = Student('lili',29,"female")

tea1 = Teacher('egon',18,"male",10)  # 空对象,'egon',18,"male",10
tea2 = Teacher('lxx',38,"male",3)

# print(stu1.school)
# print(stu1.name)
# print(stu1.age)
# print(stu1.gender)
print(tea1.__dict__)

方式二: super()返回一个特殊的对象，该对象会参考发起属性查找的那一个类的mro列表，去当前类的父类中找属性，严格依赖继承

class People:
    school = "虹桥校区"

    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

class Teacher(People):
    #            空对象,'egon',18,"male",10
    def __init__(self,name,age,gender,level):
        # People.__init__(self,name,age,gender)
        super(Teacher,self).__init__(name,age,gender)

        self.level = level

    def score(self):
        print("%s 正在为学生打分" %self.name)

tea1 = Teacher('egon',18,"male",10)  # 空对象,'egon',18,"male",10
print(tea1.__dict__)

# 案例：
class A:  # [A,object]
    def test(self):
        print("from A")
        super().test()
class B:
    def test(self):
        print('from B')
class C(A,B):  # [C,A,B,object]
    pass

# obj=C()
# obj.test()

obj1 = A()
obj1.test()

继承的实现原理

继承顺序

Python中子类可以同时继承多个父类，如A(B,C,D)

如果继承关系为非菱形结构，则会按照先找B这一条分支，然后再找C这一条分支，最后找D这一条分支的顺序直到找到我们想要的属性

如果继承关系为菱形结构，那么属性的查找方式有两种，分别是：深度优先和广度优先

# 继承顺序
class A(object):
    def test(self):
        print('from A')

class B(A):
    def test(self):
        print('from B')

class C(A):
    def test(self):
        print('from C')

class D(B):
    def test(self):
        print('from D')

class E(C):
    def test(self):
        print('from E')

class F(D,E):
    # def test(self):
    #     print('from F')
    pass
f1=F()
f1.test()
print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性

# 新式类继承顺序:F->D->B->E->C->A
# 经典类继承顺序:F->D->B->A->E->C
# python3中统一都是新式类
# pyhon2中才分新式类与经典类

菱形问题

大多数面向对象语言都不支持多继承，而在Python中，一个子类是可以同时继承多个父类的，这固然可以带来一个子类可以对多个不同父类加以重用的好处，但也有可能引发著名的 Diamond problem菱形问题(或称钻石问题，有时候也被称为“死亡钻石”)，菱形其实就是对下面这种继承结构的形象比喻

菱形继承/死亡钻石：一个子类继承的多条分支最终汇聚一个非object的类上

class G: # 在python2中，未继承object的类及其子类，都是经典类
    def test(self):
        print('from G')

class E(G):
    def test(self):
        print('from E')

class F(G):
    def test(self):
        print('from F')

class B(E):
    # def test(self):
    #     print('from B')
    pass

class C(F):
    def test(self):
        print('from C')

class D(G):
    def test(self):
        print('from D')

class A(B,C,D):
    # def test(self):
    #     print('from A')
    pass

obj = A()  # A->B->E->C->F->D->G->object
# print(A.mro())

obj.test()

• 继承原理

• python到底是如何实现继承的呢？ 对于你定义的每一个类，Python都会计算出一个方法解析顺序(MRO)列表，该MRO列表就是一个简单的所有基类的线性顺序列表，如下

A.mro()  # 等同于A.__mro__
[<class '__main__.A'>, <class '__main__.B'>, <class '__main__.E'>, <class '__main__.C'>, <class '__main__.F'>, <class '__main__.D'>, <class '__main__.G'>, <class 'object'>]

• 为了实现继承，python会在MRO列表上从左到右开始查找基类,直到找到第一个匹配这个属性的类为止。 而这个MRO列表的构造是通过一个C3线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的MRO列表并遵循如下三条准则:

• • 1.子类会先于父类被检查

    2.多个父类会根据它们在列表中的顺序被检查

    3.如果对下一个类存在两个合法的选择,选择第一个父类

• Mixins机制

  继承表达的是一个is-a的关系（什么是什么的关系）

  单继承可以很好的表达人类的逻辑（一个子类继承一个父类符合逻辑且清晰）

  多继承就有点乱，在人类的世界观里，一个物品不可能是多种不同的东西，因此多重继承

  在人类的世界观里是说不通的，它仅仅只是代码层面的逻辑（还可能导致菱形问题）

  民航飞机、直升飞机、轿车都是一个（is-a）交通工具，前两者都有一个功能是飞行fly，但是轿车没有，所以如下所示

  # 我们把飞行功能放到交通工具这个父类中是不合理的
  class Vehicle:  # 交通工具
      def fly(self):
          '''
          飞行功能相应的代码
          '''
          print("I am flying")
  
  class CivilAircraft(Vehicle):  # 民航飞机
      pass
  
  class Helicopter(Vehicle):  # 直升飞机
      pass
  
  class Car(Vehicle):  # 汽车并不会飞，但按照上述继承关系，汽车也能飞了
      pass
  
  

  Python语言没有接口功能，但Python提供了Mixins机制，简单来说Mixins机制指的是子类混合(mixin)不同类的功能，而这些类采用统一的命名规范（例如Mixin后缀），以此标识这些类只是用来混合功能的，并不是用来标识子类的从属"is-a"关系的，所以Mixins机制本质仍是多继承，但同样遵守”is-a”关系，如下

  class Vehicle:   # 交通工具
      pass
  
  class FlyableMixin:     # 定义一个飞行功能
      def fly(self):
          print('flying')
  
  class CivilAircraft(FlyableMixin,Vehicle):  # 民航飞机  继承了Flyablemixin就使用它的功能
      pass
  
  class Helicopter(FlyableMixin,Vehicle):    # 直升飞机
      pass
  
  class Car(Vehicle):             # 小汽车   不继承就不使用它的功能，也不影响
      pass
  
  # ps: 采用这种编码规范（如命名规范）来解决具体的问题是python惯用的套路，大家都照这种规范来
  # 这种规范叫什么呢？
  # 建议不要用多继承，如果要用到这个继承：把用来表达归属关系的那个类（当然也是最复杂的
  # 那个类）往多继承的最右边去放（Vehicle）。把用来添加功能的类往左边放并改名Mixin为后缀
  # 的名字（FlyableMixin）这种类的特点是这种类里面就只放功能，并且功能的特点是能独立运行
  
  

  总结：可以看到，上面的CivilAircraft、Helicopter类实现了多继承，不过它继承的第一个类我们起名

  FlyableMixin，而不是Flyable，这个并不影响功能，但是会告诉后来读代码的人，这个类是一个Mixin类

  单词表示混入(mix-in)，这个名字给人一种提示性的效果，只要以Mixin这种命名方式的类就知道这个类只

  是为我这个类来添加功能的，只要继承这个类就说明混合了这个功能

  • 组合

    组合：一个对象的属性值是指向另外一个类的对象，称为类的组合

    组合与继承都是用来解决代码的重用问题的，不同的是：

    继承是一种什么“是”什么的关系

    组合是则一种“有”什么的关系

    比如学校有学生，老师，学生有多门课程，课程有：类别、周期、学费。学生选python课程或linux课程，或多门课程，应该使用组合，如下示例

    class People:
        school = "虹桥校区"
    
        def __init__(self,name,age,gender):
            self.name = name
            self.age = age
            self.gender = gender
    
    class Student(People):
        def choose(self):
            print("%s 选课成功" %self.name)
    
    class Teacher(People):
        #            空对象,'egon',18,"male",10
        def __init__(self,name,age,gender,level):
            People.__init__(self,name,age,gender)
    
            self.level = level
    
        def score(self):
            print("%s 正在为学生打分" %self.name)
    
    class Course:
        def __init__(self,name,price,period):
            self.name = name
            self.price = price
            self.period =period
    
        def tell(self):
            print('课程信息<%s:%s:%s>' %(self.name,self.price,self.period))
    
    # 课程属性
    python = Course("python全栈开发",19800,"6mons")
    linux = Course("linux",19000,"5mons")
    
    # 学生属性
    stu1 = Student("jack",18,"male")
    stu2 = Student("tom",19,"male")
    stu3 = Student('lili',29,"female")
    
    # 老师属性
    tea1 = Teacher('egon',18,"male",10)
    tea2 = Teacher('lxx',38,"male",3)
    
    stu1.course = python   # 假如规定只有pyhton一门课程就直接等于python，这就叫组合
    stu1.course.tell()     # 直接查看课程信息
    stu1.courses = []             # 给学生1添加多门课程
    stu1.courses.append(python)   # 给学生1添加python课程
    stu1.courses.append(linux)    # 给学生1添加linux课程
    
    # 此时对象stu1集对象独有的属性、Student类中的内容、Course类中的内容于一身（都可以访问到），
    # 是一个高度整合的产物
    
    print(stu1.courses)   # 查看学生1所学的多门课程的每一门课程的信息
    for course_obj in stu1.courses:
        course_obj.tell()