继承的另一种使用方式

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

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

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

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.python支持多继承,一个类可以同时继承多个父类

好处是更加灵活

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

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

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

#super在访问父类属性的时候,是按照mro列表一层层往上找的

# 多继承虽然更灵活,但是问题也是成正比的.所以尽量不要使用多继承

组合

#组合指的是一个类把另一个类的对象作为自己的属性,就称之为组合,

组合无处不在

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

都是用来重用代码的方式.

组合描述的是什么拥有什么的关系, 比如教室对象里面有学生对象. 学生对象有电脑对象

继承描述的是什么是什么的关系. 比如佩奇是猪 , 猪猪侠也是猪

# class Person:
#     def __init__(self,name):
#         self.name = name
#
#
# p = Person("rose")
# print(p.name)


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)

菱形继承

在py2中类分为新式类和经典类,

没有直接或间接的继承object类那他就是一个经典类经典类

那么反之直接或间接的继承自object 那就是一个新式类

py3中没有这种区分了,因为不明确父类的话,系统会自动继承object 所以都是新式类

经典类和新式类在菱形继承中的查找顺序是不一样的

C3算法可以通过类名点mro 返回一个查找顺序的列表

#经典类中没有mro列表

4,接口

接口是什么呢

例如电源插座

生活中不可或缺的电, 可以给电脑电视等电器提供电源,如果想要使用.就必须给外界一个使用方式也就是插座,该方式就称之为接口

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

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

所以接口其实就是一组功能的定义,但是只清楚函数名称,而没有具体实现细节.

就相当于一套规范

就像电源插头,规定了接口的外观大小以及电源线.

电器的开发商按照这个电源插头协议来生产设备.就可以在插座上使用,就可以获得电源

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

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

接口与抽象类

抽象

　　指的是不清楚不具体.

抽象方法

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

　　要先import ABC

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

抽象类的特点是

　　不能直接实例化,必须有子类覆盖了所有抽象方法后才能实例化子类

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中不喜欢强制限制程序猿

比如说有个鼠标他的特征和行为都像usb设备,那么就可以把它当作usb设备使用

再比如某个储存设备,特征和行为都像文件,那么就可以把它当文件处理

对于使用者而言,可以不用关心这个对象是什么类,也不用关心是如何实现的

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,"一个数据...")
例如linux 有一句话叫一切皆文件 

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

来源：https://www.cnblogs.com/jixu/p/10882351.html

标签

抽象类

接口

day_25面向对象