标签：size 定义 良好的 耦合 idt 产生 提取 接口实现 包含
继承是一种创建新类的方式，
在python中，新建的类可以继承一个或多个父类(基类或超类)，新建的类是所继承的类的(派生类或子类)
python中类的继承分为：单继承和多继承
class ParentClass1: #定义父类 pass class ParentClass2: #定义父类 pass class SubClass1(ParentClass1): #单继承，基类是ParentClass1，派生类是SubClass pass class SubClass2(ParentClass1,ParentClass2): #python支持多继承，用逗号分隔开多个继承的类 pass
查看继承
>>> 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‘>,)
继承的重要性
==========================第一部分 例如 猫可以：爬树、吃、喝、拉、撒 狗可以：看门、吃、喝、拉、撒 如果我们要分别为猫和狗创建一个类，那么就需要为 猫 和 狗 实现他们所有的功能，伪代码如下： #猫和狗有大量相同的内容 class 猫： def爬树(self): print ‘爬树‘ def 吃(self): # do something def 喝(self): # do something def 拉(self): # do something def 撒(self): # do something class 狗： def 看门(self): print ‘看门‘ def 吃(self): # do something def 喝(self): # do something def 拉(self): # do something def 撒(self): # do something ==========================第二部分 上述代码不难看出，吃、喝、拉、撒是猫和狗都具有的功能，而我们却分别的猫和狗的类中编写了两次。如果使用 继承 的思想，如下实现： 动物：吃、喝、拉、撒 猫：爬树（猫继承动物的功能） 狗：看门（狗继承动物的功能） 伪代码如下： class 动物: def 吃(self): # do something def 喝(self): # do something def 拉(self): # do something def 撒(self): # do something # 在类后面括号中写入另外一个类名，表示当前类继承另外一个类 class 猫(动物)： def爬树(self): print ‘爬树‘ # 在类后面括号中写入另外一个类名，表示当前类继承另外一个类 class 狗(动物)： def 看门(self): print ‘看门‘ ==========================第三部分 #继承的代码实现 class Animal: def eat(self): print("%s 吃 " %self.name) def drink(self): print ("%s 喝 " %self.name) def shit(self): print ("%s 拉 " %self.name) def pee(self): print ("%s 撒 " %self.name) class Cat(Animal): def __init__(self, name): self.name = name self.breed = ‘猫‘ def爬树(self): print ‘爬树‘ class Dog(Animal): def __init__(self, name): self.name = name self.breed=‘狗‘ def 看门(self): print ‘看门‘ # ######### 执行 ######### c1 = Cat(‘小白家的小黑猫‘) c1.eat() c2 = Cat(‘小黑的小白猫‘) c2.drink() d1 = Dog(‘胖子家的小瘦狗‘) d1.eat() 使用继承来重用代码比较好的例子 继承可以减少代码重用
那么问题又来了，多继承呢？
1、Python的类可以继承多个类，Java和C#中则只能继承一个类
2、Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和C3算法。
经典类和新式类，从字面上可以看出一个老一个新，新的必然包含了跟多的功能，也是之后推荐的写法，从写法上区分的话，如果 当前类或者父类继承了object类，那么该类便是新式类，否则便是经典类。
class D: def bar(self): print ‘D.bar‘ class C(D): def bar(self): print ‘C.bar‘ class B(D): def bar(self): print ‘B.bar‘ class A(B, C): def bar(self): print ‘A.bar‘ a = A() # 执行bar方法时 # 首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错 # 所以，查找顺序：A --> B --> D --> C # 在上述查找bar方法的过程中，一旦找到，则寻找过程立即中断，便不会再继续找了 a.bar() 经典类多继承
class X: pass class S(X): pass class A(X): pass class B(S): pass class C(A): pass class D(B): pass class E(C): pass class F(D,E,B): pass f1 = F() print(F.mro()) #[<class ‘__main__.F‘>, <class ‘__main__.D‘>, <class ‘__main__.E‘>, <class ‘__main__.B‘>, <class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘object‘>]
经典类：首先去A类中查找，如果A类中没有，则继续去B类中找，如果B类中么有，则继续去D类中找，如果D类中么有，则继续去C类中找，如果还是未找到，则报错
新式类：则根据C3算法，具体可以通过类名.mro()方法去查询他的继承顺序。
注意：在上述查找过程中，一旦找到，则寻找过程立即中断，便不会再继续找了
抽象类与接口类
接口类
继承有两种用途：
一：继承基类的方法，并且做出自己的改变或者扩展（代码重用）
二：声明某个子类兼容于某基类，定义一个接口类Interface，接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中的功能
# 一:这样不好,我要统一一下支付的规则. class QQpay: def pay(self,money): print(‘使用qq支付%s元‘ % money) class Alipay: def pay(self,money): print(‘使用阿里支付%s元‘ % money) a = Alipay() a.pay(100) b = QQpay() b.pay(200) # 二,统一支付的规则 归一化设计,统一 pay接口 class QQpay: def pay(self,money): print(‘使用qq支付%s元‘ % money) class Alipay: def pay(self,money): print(‘使用阿里支付%s元‘ % money) def pay(obj,money): obj.pay(money) a = Alipay() b = QQpay() pay(a,100) pay(b,200) # 三,但是,来了一个野生程序员,他不知道你的约定俗成的规则,就会出问题 class QQpay: def pay(self,money): print(‘使用qq支付%s元‘ % money) class Alipay: def pay(self,money): print(‘使用阿里支付%s元‘ % money) class Wechatpay: def fuqian(self,money): print(‘使用微信支付%s元‘ % money) def pay(obj,money): obj.pay(money) a = Alipay() b = QQpay() pay(a,100) pay(b,200) c = Wechatpay() c.fuqian(300) # 四,解决方式 # 定义一个父类,什么都不写,只是要求继承我的所有类有一个pay方法,这样就制定了一个规范,这就叫做接口类,后者抽象类. class Payment: def pay(self):pass class QQpay(Payment): def pay(self,money): print(‘使用qq支付%s元‘ % money) class Alipay(Payment): def pay(self,money): print(‘使用阿里支付%s元‘ % money) class Wechatpay(Payment): def fuqian(self,money): print(‘使用微信支付%s元‘ % money) def pay(obj,money): obj.pay(money) a = Alipay() b = QQpay() pay(a,100) pay(b,200) c = Wechatpay() c.fuqian(300) #五,他还是不知道看你这些都继承了一个类,所以你要制定一个规范,强制他执行. # 创建一个规范 from abc import ABCMeta,abstractmethod class Payment(metaclass=ABCMeta): # 抽象类 接口类 规范和约束 metaclass指定的是一个元类 @abstractmethod def pay(self):pass # 抽象方法 class Alipay(Payment): def pay(self,money): print(‘使用支付宝支付了%s元‘%money) class QQpay(Payment): def pay(self,money): print(‘使用qq支付了%s元‘%money) class Wechatpay(Payment): # def pay(self,money): # print(‘使用微信支付了%s元‘%money) def recharge(self):pass def pay(a,money): a.pay(money) a = Alipay() a.pay(100) pay(a,100) # 归一化设计：不管是哪一个类的对象，都调用同一个函数去完成相似的功能 q = QQpay() q.pay(100) pay(q,100) w = Wechatpay() pay(w,100) # 到用的时候才会报错 # 抽象类和接口类做的事情 ：建立规范 # 制定一个类的metaclass是ABCMeta， # 那么这个类就变成了一个抽象类(接口类) # 这个类的主要功能就是建立一个规范 接口类示例
实践中，继承的第一种含义意义并不很大，甚至常常是有害的。因为它使得子类与基类出现强耦合。
继承的第二种含义非常重要。它又叫“接口继承”。
接口继承实质上是要求“做出一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上，叫做归一化。
归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕（当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定）。
为什么用接口
接口提取了一群类共同的函数，可以把接口当做一个函数的集合。 然后让子类去实现接口中的函数。 这么做的意义在于归一化，什么叫归一化，就是只要是基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样。 归一化，让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。 比如：我们定义一个动物接口，接口里定义了有跑、吃、呼吸等接口函数，这样老鼠的类去实现了该接口，松鼠的类也去实现了该接口，由二者分别产生一只老鼠和一只松鼠送到你面前，
即便是你分别不到底哪只是什么鼠你肯定知道他俩都会跑，都会吃，都能呼吸。 再比如：我们有一个汽车接口，里面定义了汽车所有的功能，然后由本田汽车的类，奥迪汽车的类，大众汽车的类，他们都实现了汽车接口，这样就好办了，大家只需要学会了怎么开汽车，
那么无论是本田，还是奥迪，还是大众我们都会开了，开的时候根本无需关心我开的是哪一类车，操作手法（函数调用）都一样
标签：size 定义 良好的 耦合 idt 产生 提取 接口实现 包含
原文地址：https://www.cnblogs.com/jin-yuana/p/10025474.html
