继承的另一种使用方式 super（）的问题组合菱形继承接口与抽象类鸭子类型

.继承的另一种使用方式

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

2.继承已有得类来扩展新功能

当你要创建一个新类，发现这个类中的一切在某一些类中已经存在，可以直接继承已有的类，然后再补充如下所见

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

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

# li = list()
# li = MyList()
# # li.append(10)
# # li.append(20)
# #
# # print(li)
#
# li.append("hello")
# li.append(20)
#
# print(li)

.super（）的问题 mro列表

python支持多继承，就是说一个类可以继承多个父类

优点：更加灵活

缺点：属性的查找顺序不好确定（比如说父类中出现了同名的属性或函数）

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

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

.组合

　　组合无处不在，是指一个类把另一个类的对象作为自己的属性的行为。比如说你定义一个类，但这个类拥有某种类型的属性时称之为组合。

优点：提高代码的复用性

组合与继承的区别：

组合：描述的是什么拥有什么的关系 eg：学生有数

继承：描述的是什么是什么的关系 eg：猪猪侠是猪

# 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)
```

.菱形继承

定义：一个类有多个父类，于此同时多个父类同时继承另一个父类

经典类：没有继承自object得类，存在于py2 中

新式类：直接或间接继承自object得类 py3中全是新式类

菱形继承在经典类中查找属性的顺序是深度优先一路顺到底，在看其他路的

菱形继承在新式类中查找属性的顺序是先深度再广度

【多层的菱形继承】
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)
# 新式类的顺序
# E  B C D A object 
# 经典类的顺序
# E B A C D
# print(E.mro())

注意:经典类没有mro列表

接口与抽象的类

接口：在程序中功能用函数表示，但外界会只知道函数名而不知道函数如何实现的，这个函数名就是借口（一组功能的定义）它相当于一套规范

优点：使用接口可以提高程序的扩展性只要对象按照接口规定方法来实现，使用者可以无差别使用所有对象

```python
class USB:

    def open(self):
        pass

    def close(self):
        pass

    def work(self):
        pass
```

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

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

抽象类：如果类中具备抽象方法，那么这个类就是抽象类

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

　　　　　抽象类中可以存在非抽象方法　

　　作用：通过抽象类来强行限制子类必须覆盖所有的抽象方法

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

小结：抽象类与接口的区别：接口只有申明而没有实现提，接口中所有方法都是抽象的；而抽象类中只要有抽象方法就行。

.鸭子类型 py中推荐使用，但不强行限制你

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

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

```



案例2:

```python
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可以无差别对待任何设备!

继承的另一种使用方式 super（）的问题 组合 菱形继承 接口与抽象类 鸭子类型

猜你喜欢

继承的另一种使用方式 super（）的问题组合菱形继承接口与抽象类鸭子类型