Python3 学习笔记 -- 继承

小小糖

先上一个比较简单的单继承语法。在python3中，基类的构造函数不会被自动调用，需要手动调用，同样的
方法也是这样，需要手动调用。可以使用类名称+init方法，也可以使用super语法进行调用。在下面这个例子
中，子类继承了基类的方法和字段。字段会在基类中初始化。

1. 
   
2. 
   
3. 
   
4. class BaseClass:   
   
5.     def __init__(self):
   
6.         self.name = 'BaseClass'
   
7.         print('BaseCalss: Constructor called')
   
8.     def getname(self):
   
9.         print('BaseCalss: self name equals ' + self.name)
   
10. 
    
11. class DerivedClass(BaseClass):
    
12.     def __init__(self):
    
13.         super().__init__()
    
14.         print('DerivedClass: Constructor called')
    
15. 
    
16. if __name__ == '__main__':
    
17.     class1 = BaseClass()
    
18.     class1.getname()
    
19.    
    
20.     class2 = DerivedClass()
    
21.     class2.getname()
    
22. 运行结果：
    
23. 
    
24. BaseCalss: Constructor called
    
25. BaseCalss: self name equals BaseClass
    
26. BaseCalss: Constructor called
    
27. DerivedClass: Constructor called
    
28. BaseCalss: self name equals BaseClass
    
29. 
    
30. 
    
31. 子类也可以overwrite父类的方法，那么父类的方法就不会被调用，除非手动调用：
    
32. 
    
33. class BaseClass:   
    
34.     def __init__(self):
    
35.         self.name = 'BaseClass'
    
36.         print('BaseCalss: Constructor called')
    
37.     def getname(self):
    
38.         print('BaseCalss: self name equals ' + self.name)
    
39. 
    
40. class DerivedClass(BaseClass):
    
41.     def __init__(self):
    
42.         super().__init__()
    
43.         print('DerivedClass: Constructor called')
    
44.     def getname(self):
    
45.         print('self.name init value is ' + self.name)
    
46.         self.name = 'DerivedClass'
    
47.         print('DerivedClass: self name equals ' + self.name)
    
48. 
    
49. if __name__ == '__main__':
    
50.     class1 = BaseClass()
    
51.     class1.getname()
    
52.    
    
53.     class2 = DerivedClass()
    
54.     class2.getname()
    

复制代码

运行结果：

BaseCalss: Constructor called
BaseCalss: self name equals BaseClass
BaseCalss: Constructor called
DerivedClass: Constructor called
self.name init value is BaseClass
DerivedClass: self name equals DerivedClass



python不仅仅支持单继承，还支持多继承，字段和方法都可以被继承。在多继承super()只能代表继承的第
一个父类，所以您在子类的构造函数中，不能单独使用super().__init__()， 那只是表示调用其中一个基类的
构造函数。所以用super就不是那么好用了。还是要用会原来的类名+init方法来调用。

1. 
   
2. class BaseClass1:
   
3.     def __init__(self):
   
4.         self.name1 = 'BaseClass1_Name1'
   
5.         self.name = 'BaseClass1_Name'
   
6.         print('BaseCalss1: Constructor called')
   
7.     def getname1(self):
   
8.         print('BaseCalss1: self name1 equals ' + self.name1)
   
9.     def getname(self):
   
10.         print('BaseCalss1: getname called, name equal ' + self.name)
    
11. 
    
12. class BaseClass2:
    
13.     def __init__(self):
    
14.         self.name2 = 'BaseClass2_Name2'
    
15.         self.name = 'BaseClass2_Name'
    
16.         print('BaseClass2: Constructor called')
    
17.     def getname2(self):
    
18.         print('BaseClass2: self name2 equals ' + self.name2)
    
19.     def getname(self):
    
20.         print('BaseCalss2: getname called, name equal ' + self.name)
    
21. 
    
22. class DerivedClass2(BaseClass1, BaseClass2):
    
23.     def __init__(self):
    
24.         BaseClass1.__init__(self)
    
25.         BaseClass2.__init__(self)
    
26.         print('DerivedClass: Constructor called')
    
27.         
    
28. if __name__ == '__main__':
    
29.     class1 = BaseClass1()
    
30.     class1.getname1()
    
31.    
    
32.     class2 = BaseClass2()
    
33.     class2.getname2()
    
34.    
    
35.     class3 = DerivedClass2()
    
36.     class3.getname1()
    
37.     class3.getname2()
    
38.     class3.getname()
    
39. 运行结果：
    
40. 
    
41. BaseCalss1: Constructor called
    
42. BaseCalss1: self name1 equals BaseClass1_Name1
    
43. BaseClass2: Constructor called
    
44. BaseClass2: self name2 equals BaseClass2_Name2
    
45. BaseCalss1: Constructor called
    
46. BaseClass2: Constructor called
    
47. DerivedClass: Constructor called
    
48. BaseCalss1: self name1 equals BaseClass1_Name1
    
49. BaseClass2: self name2 equals BaseClass2_Name2
    
50. BaseCalss1: getname called, name equal BaseClass2_Name

复制代码

我们可以看到，当两个基类有方法重名的时候，python3会按照您继承类的从左到右的顺序查找您调用的方
法DerivedClass2(BaseClass1, BaseClass2)。在这个例子中，是先找BaseClass1，然后再找BaseClass2。

如果您的代码需要多层继承的话，可以参开多重继承的 Diamond Problem 问题。

1. 
   
2. class A1:
   
3.     def foo1(self):
   
4.         print("Call A1's foo1")
   
5. class A2:
   
6.     def foo1(self):
   
7.         print("Call A2's foo1")
   
8.     def foo2(self):
   
9.         print("Call A2's foo2")
   
10. 
    
11. class B1(A1,A2):
    
12.     pass
    
13. class B2(A1,A2):
    
14.     def foo2(self):
    
15.         print("Call B2's foo2")
    
16.         
    
17. class C(B1,B2):
    
18.     pass
    
19. 
    
20. if __name__ == '__main__':
    
21.    
    
22.     class1 = C()
    
23.     class1.foo1()
    
24.     class1.foo2()
    

复制代码

运行结果：

Call A1's foo1
Call B2's foo2

所以对于python3 的多层继承来说，因为都是新式类，总是从左到右，广度优先的方式进行。

梦想家