面向对象二

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

最常见的是直接继承一个已经存在的类

当你想要创建一个新的类 发现这个类中的一些 在某一个类中已经存在

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

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__)

2.super()的问题 mro列表

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

好处是更加灵活

多继承时如果多个父类中出现了同名的属性/函数
你不能用看来判断查找顺序 ,需要使用mro列表来查看真正的继承顺序，super在访问父类属性时 是按照mro列表一层层往上找的

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()

  注意事项： 尽量不要使用多继承

二. 组合
指的是 一个类把另一个类的对象作为自己的属性 就称之为组合
无处不在
当你定义一个类 并且这个类拥有某种类型的属性时 就称之为组合
都是用用来重用代码的方式:
组合描述的是 什么拥有什么的关系   什么有什么，什么有什么
基础描述的是 什么是什么的关系      什么是什么，什么是什么

class PC:
    def open_app(self,app_name):
        print("open %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)

三.新式类与经典类

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()

新式类：直接或间接继承object，就是新式类，py3中都是的
经典类：没有直接或间接继承object，就是经典类，一般出现在py2中

四.接口

接口：就是一套协议规范

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

接口中不应该包括非抽象方法的函数

接口的示例如下：

class USB:

    def open(self):
        pass

    def close(self):
        pass

    def work(self):
        pass

接口的好处是：

使用接口可以提高程序的扩展性

只要对象按照接口规定方法来实现,使用者就可以无差别使用所有对象

五.抽象类

抽象：指的就是，不清楚，不明白，看不懂

抽象方法：指的是 没有函数体的方法 用@abc.abstractmethod 装饰器，如果类中具备抽象方法 那么这个类就称之为抽象类

抽象与接口的区别：不能直接实例化 必须有子类覆盖了所有抽象方法后才能实例化子类

举例：

import abc

class Test(metaclass=abc.ABCMeta):

    @abc.abstractmethod
    def say_hi(self):
        pass

class TT(Test):

    def say_hi(self):
        print("i am TT obj")

t = TT()
t.say_hi()

六.鸭子类型

鸭子类型：说如果一个对象叫声像鸭子,走路像鸭子,长得像鸭子,那它就是鸭子

python不喜欢限制一个人，鸭子类型就是python推荐的方法：

举例如下：

class PC():

    def conntent_device(self, usb_device):
        usb_device.open()
        usb_device.work()
        usb_device.close()

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

    def work(self):
        print("mouse working...")

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

mouse = Mouse()
pc = PC()

pc.conntent_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.conntent_device(key1)

示例二：

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,"一个数据...")