第19-21天

组合：

　　类似于类中类的概念，或者说是如同一个树状图，如

　　class A：

　　　　def __init__(self, a, b):

　　　　　　self.a = a

　　　　　　self.b = b

　　class B

　　　　def __init__(self,c)

　　　　　　self.c = c

　　b = B(ccc')

　　abc = A('aaa',b)

　　print(abc.__dict__)　

结果应该是　　{'b': <__main__.B object at 0x0000028D7D33EF28>, 'a': 'aaa'}　 　，这里的b对应的值也是一个class

继承 :

　　class A : 

　　　　def __init__(self, a, b):

　　　　　　self.a = a

　　　　　　self.b = b

　　class B(A):

　　　　def __init__(self, a, b, c):

　　　　　　super().__init__(a, b)

　　则：

　　asd = B(a , b, c)　　需要三个参数。继承则共用A中的方法与属性

钻石继承：

　　新式类，按照广度优先，调用路线好比走路，当还有其他点能到下个点的时候，优先走另一条路  （PY2中表达方法是类继承object，3中全是新式类）

　　经典类：按着深度优先，可以理解为一条路一直走到头

接口类：一种规范化

　　from abc import ABCMeta,abstractmethod

　　class Py(metaclass= ABCMeta):

　　　　@abstractmethod

　　　　def ppp(self,a):pass

　　若此时Be类继承Py类，则必须有ppp这个方法，即：

　　class Be(Py):

　　　　def ppp(self,a): pass

　　都叫一个名字了以后，就可以归一化管理：

　　def aaa(a, b):

　　　　a.ppp(b)　　　　　　做到统一调用

如同：

　　

from abc import ABCMeta,abstractmethod
class A(metaclass= ABCMeta):
     @abstractmethod
     def ppp(self,b):
         print(b+1)


class B(A):
    def __init__(self,r):
        self.a = r
    def ppp(self,a):
        print(a)

class C(A):
    def __init__(self, r):
        self.a = r
    def ppp(self,b):
         print(b+1)

def aaa(a, b):
    a.ppp(b)

c = C(0)
b = B(2)
a = aaa(c, 10)

鸭子模型：

　　　　是一种格式，即不用上述方法强制限制，而是程序员自己按照格式走

多态：　　　

　　　　java中存在多态。当函数需要传参的时候，需要固定参数的类型，如public class A entend B (int a, int b)称之为多态

　　　　Python中不存在多态（说法不一），跟确切的说是使用的方法跳过了这个判定的阶段