Python-面向对象-继承

继承.

继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类

python中类的继承分为：单继承和多继承

 1 复制代码
 2 class ParentClass1: #定义父类
 3     pass
 4 
 5 class ParentClass2: #定义父类
 6     pass
 7 
 8 class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass
 9     pass
10 
11 class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类
12     pass

View Code

查看继承

>>> SubClass1.__bases__ #__base__只查看从左到右继承的第一个子类，__bases__则是查看所有继承的父类
(<class '__main__.ParentClass1'>,)
>>> SubClass2.__bases__
(<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

　　提示：如果没有指定基类，python的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法（如__str__）的实现。

>>> ParentClass1.__bases__
(<class 'object'>,)
>>> ParentClass2.__bases__
(<class 'object'>,)

　　继承的重要性

  1 ==========================第一部分
  2 例如
  3 
  4 　　猫可以：爬树、吃、喝、拉、撒
  5 
  6 　　狗可以：看门、吃、喝、拉、撒
  7 
  8 如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能，伪代码如下：
  9  
 10 
 11 #猫和狗有大量相同的内容
 12 class 猫：
 13 
 14     def爬树(self):
 15         print '爬树'
 16 
 17     def 吃(self):
 18         # do something
 19 
 20     def 喝(self):
 21         # do something
 22 
 23     def 拉(self):
 24         # do something
 25 
 26     def 撒(self):
 27         # do something
 28 
 29 class 狗：
 30 
 31     def 看门(self):
 32         print '看门'
 33 
 34     def 吃(self):
 35         # do something
 36 
 37     def 喝(self):
 38         # do something
 39 
 40     def 拉(self):
 41         # do something
 42 
 43     def 撒(self):
 44         # do something
 45 
 46 
 47 
 48 ==========================第二部分
 49 上述代码不难看出，吃、喝、拉、撒是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想，如下实现：
 50 
 51 　　动物：吃、喝、拉、撒
 52 
 53 　　   猫：爬树（猫继承动物的功能）
 54 
 55 　　   狗：看门（狗继承动物的功能）
 56 
 57 伪代码如下：
 58 class 动物:
 59 
 60     def 吃(self):
 61         # do something
 62 
 63     def 喝(self):
 64         # do something
 65 
 66     def 拉(self):
 67         # do something
 68 
 69     def 撒(self):
 70         # do something
 71 
 72 # 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
 73 class 猫(动物)：
 74 
 75     def爬树(self):
 76         print '爬树'
 77 
 78 # 在类后面括号中写入另外一个类名，表示当前类继承另外一个类
 79 class 狗(动物)：
 80 
 81      def 看门(self):
 82         print '看门'
 83 
 84 
 85 
 86 
 87 ==========================第三部分
 88 #继承的代码实现
 89 class Animal:
 90 
 91     def eat(self):
 92         print("%s 吃 " %self.name)
 93 
 94     def drink(self):
 95         print ("%s 喝 " %self.name)
 96 
 97     def shit(self):
 98         print ("%s 拉 " %self.name)
 99 
100     def pee(self):
101         print ("%s 撒 " %self.name)
102 
103 
104 class Cat(Animal):
105 
106     def __init__(self, name):
107         self.name = name
108         self.breed = '猫'
109 
110     def爬树(self):
111         print '爬树'
112 
113 class Dog(Animal):
114 
115     def __init__(self, name):
116         self.name = name
117         self.breed='狗'
118   
119     def 看门(self):
120         print '看门'
121 
122 
123 
124 # ######### 执行 #########
125 
126 c1 = Cat('小白家的小黑猫')
127 c1.eat()
128 
129 c2 = Cat('小黑的小白猫')
130 c2.drink()
131 
132 d1 = Dog('胖子家的小瘦狗')
133 d1.eat()
134 
135 使用继承来重用代码比较好的例子继承的重要性
136 
137 继承可以减少代码重用

View Code

那么问题又来了，多继承呢？

是否可以继承多个类
如果继承的多个类每个类中都定了相同的函数，那么那一个会被使用呢？

1、Python的类可以继承多个类，Java和C#中则只能继承一个类

2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先

当类是经典类时，多继承情况下，会按照深度优先方式查找
当类是新式类时，多继承情况下，会按照广度优先方式查找

经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。

 1 class D:
 2 
 3     def bar(self):
 4         print 'D.bar'
 5 
 6 
 7 class C(D):
 8 
 9     def bar(self):
10         print 'C.bar'
11 
12 
13 class B(D):
14 
15     def bar(self):
16         print 'B.bar'
17 
18 
19 class A(B, C):
20 
21     def bar(self):
22         print 'A.bar'
23 
24 a = A()
25 # 执行bar方法时
26 # 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
27 # 所以，查找顺序：A --> B --> D --> C
28 # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
29 a.bar()
30 
31 经典类多继承
32 
33 经典类多继承

经典类多继承

 1 class D(object):
 2 
 3     def bar(self):
 4         print 'D.bar'
 5 
 6 
 7 class C(D):
 8 
 9     def bar(self):
10         print 'C.bar'
11 
12 
13 class B(D):
14 
15     def bar(self):
16         print 'B.bar'
17 
18 
19 class A(B, C):
20 
21     def bar(self):
22         print 'A.bar'
23 
24 a = A()
25 # 执行bar方法时
26 # 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错
27 # 所以，查找顺序：A --> B --> C --> D
28 # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
29 a.bar()
30 
31 新式类多继承

新式类多继承

经典类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错

新式类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去C类中找，如果C类中么有，则继续去D类中找，如果还是未找到，则报错

注意：在上述查找过程中，一旦找到，则寻找过程立即中断，便不会再继续找了