编写类之四再论继承

在上一讲代码的基础上，做进一步修改，成为了如下程序，请看官研习这个程序：

  1. #!/usr/bin/env python
  2. #coding:utf-8
  4. class Person:
  5.     def __init__(self, name, email):
  6.         self.name = name
  7.         self.email = email
  9. class Programmer(Person):
  10.     def __init__(self, name,email,lang, system, website):
  11.         Person.__init__(self,name,email)
  12.         self.lang = lang
  13.         self.system = system
  14.         self.website = website
  16. class Pythoner(Programmer):
  17.     def __init__(self,name,email):
  18.         Programmer.__init__(self,name,email,"python","Ubuntu","qiwsir.github.io")
  20. if __name__=="__main__":
  21.     writer = Pythoner("qiwsir","qiwsir@gmail.com")
  22.     print "name=",writer.name
  23.     print "lang=",writer.lang
  24.     print "email=",writer.email
  25.     print "system=",writer.system
  26.     print "website=",writer.website
  28. #运行结果
  30. name= qiwsir
  31. lang= python
  32. email= qiwsir@gmail.com
  33. system= Ubuntu
  34. website= qiwsir.github.io

对结果很满意，再看程序中的继承关系：Pythoner <— Programmer <— Person，从上面的过程中不难看出，继承能够减少代码重复，是的代码更简练。另外，在继承的时候，也可以在函数中对参数进行默认赋值。

为了能够突出继承问题的探究，还是用那种简单的类来做实验。

多余的B

  1. #!/usr/bin/env python
  2. #coding:utf-8
  4. class A:
  5.     def __init__(self):
  6.         print "aaa"
  8. class B(A):
  9.     pass
  11. if __name__=="__main__":
  12.     a = A()
  13.     b = B()
  15. #运行结果
  17. aaa
  18. aaa

B继承A，没有任何修改地继承，B就可以不用写任何东西了，或者说B本质上就是一个多余。在真实的编程过程中，没有这样写的，这里仅仅是为了向看官展示一下继承的含义罢了。

  1. ##首个继承有效
  3. #!/usr/bin/env python
  4. #coding:utf-8
  6. class A:
  7.     def __init__(self):
  8.         print "aaa"
  10. class B:
  11.     def __init__(self):
  12.         print "bbb"
  14. class C1(A,B):
  15.     pass
  17. class C2(B,A):
  18.     pass
  20. if __name__=="__main__":
  21.     print "A--->",
  22.     a = A()
  23.     print "B--->",
  24.     b = B()
  25.     print "C1(A,B)--->",
  26.     c1 = C1()
  27.     print "C2(B,A)--->",
  28.     c2 = C2()
  30. #运行结果
  32. A---> aaa
  33. B---> bbb
  34. C1(A,B)---> aaa
  35. C2(B,A)---> bbb

列位看官是否注意了，类C1继承了两个类A，B；类C2也继承了两个类，只不过书写顺序有点区别(B,A)。从运行结果可以看出，当子类继承多个父类的时候，对于构造函数__init__()，只有第一个能够被继承，第二个就等掉了。所以，一般情况下，不会在程序中做关于构造函数的同时多个继承，不过可以接力继承，就如同前面那个比较真实的代码一样。

其它方法的继承

  1. #!/usr/bin/env python
  2. #coding:utf-8
  4. class A:
  5.     def __init__(self):
  6.         print "aaa"
  7.     def amethod(self):
  8.         print "method a"
  10. class B(A):
  11.     def __init__(self):
  12.         print "bbb"
  15. if __name__=="__main__":
  16.     print "A--->"
  17.     a = A()
  18.     a.amethod()
  19.     print "B--->"
  20.     b = B()
  21.     b.amethod()
  23. #运行结果
  25. A--->
  26. aaa
  27. method a
  28. B--->
  29. bbb
  30. method a

为了说明白上面的情况，还是画了一张图，不过，我画完之后，就后悔了，看这张图好像更糊涂了。怎么着也画了，还是贴出来，如果能够协助理解更好了。

编写类之四再论继承 - 图1

A的实例和调用，就不多说了。重点看B，类B继承了A，同时，B在构造函数中自己做了规定，也就是B的构造函数是按照B的意愿执行，不执行A的内容，但是，A还有一个amethod(self)方法，B则继承了这个方法。当通过类B的实例调用这个方法的时候，就能够成功了：b.amethod()

这就是方法的继承和调用方法。

所谓继承，就是从下到上一级一级地找相应的继承对象，找到了就继承之。如果有同名的怎么办？按照什么顺序找呢？

应用网上的一段：

在Python中，可以進行多重繼承，這個時候要注意搜尋的順序，是從子類別開始，接著是同一階層父類別由左至右搜尋，再至更上層同一階層父類別由左至右搜尋，直到達到頂層為止。

代码举例：

  1. class A(object):
  2.     def method1(self):
  3.         print('A.method1')
  5.     def method2(self):
  6.         print('A.method2')
  8. class B(A):
  9.     def method3(self):
  10.         print('B.method3')
  12. class C(A):
  13.     def method2(self):
  14.         print('C.method2')
  16.     def method3(self):
  17.         print('C.method3')
  19. class D(B, C):
  20.     def method4(self):
  21.         print('C.method4')
  23. d = D()
  24. d.method4() # 在 D 找到，C.method4
  25. d.method3() # 以 D->B 順序找到，B.method3
  26. d.method2() # 以 D->B->C 順序找到，C.method2
  27. d.method1() # 以 D->B->C->A 順序找到，A.method1

务必请真正的学习者要对照每个类的每个方法，依次找到相应的输出结果。从而理解继承的顺序。学习，就要点滴积累。