继承的使用方法，多继承的问题，组合，菱形继承的概念，接口，接口与抽象，鸭子类型，

1.继承的另一种使用方法

2.多继承的问题

3.组合

4.菱形继承的概念

5.接口

6.接口与抽象

7.鸭子类型

1.  继承的另一种使用方式

最常见的是直接继承一个已经存在的类，当你想要创建一个新类，发现这个类中的一些属性方法，再某一个类中已经存在

那就没有必要从头开始写，可以直接继承已有的类，然后补充

'''
实现一个存储类 在提供基本的存取功能之外 还要可以限制存储元素的类型
'''

class MyList(list):
    def __init__(self, element_cls):
        # 当你覆盖了init方法时，
        # 不要忘记调用super().init函数让父类完成原有的初始化操作
        super().__init__()
        self.element_cls = element_cls

    def append(self, object):
        # if isinstance(object,str)
        if object.__class__ == self.element_cls:
            super().append(object)

        else:
            print('只能存储%s类型' % self.element_cls.__name__)

li = MyList(str)
li.append(10)
li.append('123')
print(li)

2. super()的问题，mro列表

python支持多继承 一个类可以同时继承多个父类

好处是更加灵活

问题是：属性查找顺序该怎么确定

# 案例：
# class A:
#     a = 1
#     pass
# class B(A):
#     a = 2
#     pass
# class C(A):
#     a = 3
#     pass
# class D(A):
#     a = 4
#     pass
# class E(B,C,D):
#     a = 5
#     pass
#
# e1 = E()
#
# print(e1.a)
#
# print(E.mro()) # 查找顺序
# [<class '__main__.E'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class '__main__.A'>, <class 'object'>]

# 问题点：多继承时，如果多个父类中出现了同名的属性/函数

# 你不能用眼睛去判断查找顺序，需要使用mro列表来查看真正的继承顺序

# 总结：super在访问父类属性时，是按照mro列表一层层往上找的

3.多继承的问题

# 测试

# 测试
class A:
    def test(self):
        print('from A')
        super().test()  #  应该报错，但是却执行成功了


class B:
    def test(self):
        print('from B')
    pass

class C(A,B):
    pass

c = C()
C.test(c)


# 最后： 尽量不要使用多继承

4.组合：

指的是 一个类把另一个类的对象作为自己的属性，就称之为组合，无处不在

当你定义一个类，并且这个类拥有某种类型的属性时，就称之为组合

都是用来重用代码的方式

组合描述的是 什么拥有什么的关系， 学生拥有书，学生拥有电脑

基础描述的是 什么是什么的关系        麦兜是猪，猪猪侠也是猪

案例：

class PC:
    def open_app(self, app_name):
        print('打开%s' % app_name)


class OldBoyStudent:
    def __init__(self, PC, notebook):
        self.PC = PC
        self.notebook = notebook

    pass


pc = PC()
notebook = PC()

# 将两个类组合使用，
stu = OldBoyStudent(pc, notebook)
stu.notebook.open_app('QQ')

5.菱形继承的概念

经典类与新式类

经典类: 没有继承object 的类就称之为经典类，只出现在py2种

新式类：直接或继承了object 的类就称之为新式类，py3中全都是新式类

菱形继承：

一个类有多个父类，多个父类之间又同时继承另一个父类，就产生了菱形继承

# 如果菱形继承在经典类中：查找顺序是深度优先

# 如果菱形继承在新式类中：由C3算法来确定继承顺序，先深度再广度

案列

class A:
    pass
class B(A):
    pass
class C(A):
    pass
class D(A):
    pass
class E(B,C,D):
    pass

6.接口

例如USB

电脑内部具被USB相应的功能，如果要使用的话，就必须给外界提供一个使用方式就称之为接口

再程序中功能通常是用函数来表示，对于外界而言，无需清楚函数是如何实现的，只要知道函数名即可，这个函数名称就可以称之为接口

外界调用接口就能完成某个任务

接口其实就是一组功能的定义，但是只清楚函数名称，而没有具体的实现细节，相当与一套规范

例如USB 规定了接口的外观，大小，以及每条线路的功能是什么

硬件开发商照着这个USB协议来生产设备，就可以被电脑使用

案列：

import abc
'''
接口就是一套协议规范
具体表现形式：由一堆函数，但是只明确了函数的名称，没有明确函数具体是实现
'''

class USB(): 
　　def open(self):
        pass

　　def close(self):
        pass

　　def work(self):
        pass

7.接口与抽象

 抽象：　　指的是不清楚，不具体，看不懂

抽象方法:　指的是没有函数体的方法 用@abc.abstractmethod 装饰器

　　　　　 如果类中具备抽象方法 ，那么这个类就称之为抽象类

抽象类的特点：不能直接实例化，必须有子类覆盖了所有抽象方法后才能实例化子类

与接口的区别：接口是指只有方法声明而没有实现体，接口中所有的方法都是抽象的

案例：

'''
抽象类
具有抽象方法的类
抽象方法是 没有函数体的方法

抽象类的特点  不能直接实例化

'''

import abc


class Test(metaclass=abc.ABCMeta):

    @abc.abstractmethod
    def say_hi(self):
        pass
    # 抽象类中，一般不会单独添加属性方法。
    def info(self):
        print('my class is Test')


class DD(Test):
    # 继承之后必须重写抽象功能，不写会报错
    def say_hi(self):
        print('i am DD obj')


t = DD()
t.info()

问题：如果接口的子类没有实现接口中的方法，那是没有任何意义的

抽象类之所以出现的意义：通过抽象类来强行限制子类，必须覆盖所有的抽象方法

8.鸭子类型

说如果一个对象叫声像鸭子，走路像鸭子，长得像鸭子，那他就是鸭子

是python推荐的方式，python不喜欢强行限制你

案例1：

# 鸭子类型
class PC():

    def countent_device(self,usb_device): # 传入功能
        usb_device.open()   # 加括号调用
        usb_device.work()
        usb_device.close()

class Mouse:
    # 实现接口规定的所有功能
    def open(self):
        print('mouse opend')

    def work(self):
        print('mouse working')

    def close(self):
        print('mouse closed')

# 拿到类对象
mouse = Mouse()
pc = PC()

# 传入PC中调用
pc.countent_device(mouse)

class KeyBoard:
    def open(self):
        print('KeyBoard opened')

    def work(self):
        print('KeyBoard working...')

    def close(self):
        print('KeyBoard closed')

key1 = KeyBoard()

# 如果key1的特征和行为都像USB设备，那就把它当作USB设备来使用
# 对于使用者而言可以不用关心这个对象是什么类，是如何实现的
pc.countent_device(key1)

案例2：

# 鸭子类型
class Linux:
    def read_data(self, device):
        data = device.read()
        return data

    def write_data(self, device, data):
        device.write(data)


class Disk:
    def read(self):
        print('disk reading...')
        return '这是一个磁盘上的数据'

    def write(self, data):
        print('disk writing %s..' % data)


class UP:
    def read(self):
        print('disk reading...')
        return '这是一个U盘上的数据'

    def write(self, data):
        print('disk writing %s..' % data)

# 拿到类对象
l = Linux()
d = Disk()



data = l.read_data(d)
l.write_data(d, '这是一个数据。。')

up1 = UP()
l.read_data(up1)
l.write_data(up1,'还是一个数据')

# 例如linux 有一句话叫一切皆文件

# 之所以这么设计是为了提高扩展性,让Linux可以无差别对待任何设备!