java 菱形继承,25 继承 多继承 组合 菱形继承 接口 鸭子类型

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

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

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

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

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

class School(list):

def __init__(self, element_cls):

# 当你覆盖了init方法时

# 不要忘记调用super().init函数让父类完成原有的初始化操作

super().__init__()

self.element_cls = element_cls

def append(self, obj):

# if isinstance(object,str) # 判断要存储的元素是否是指定类型

if obj.__class__ == self.element_cls:

super().append(obj)

else:

print('只能是%s' % self.element_cls.__name__)

# self.element_cls(__name__)

l = School(str)

l.append(12)

l.append('147')

print(l)

# 多继承

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

print(C.mro())

# 当你使用super()函数时,

# Python会在MRO列表上继续搜索下一个类。

# 只要每个重定义的方法统一使用super()并只调用它一次

# ,那么控制流最终会遍历完整个MRO列表,

# 每个方法也只会被调用一次

(# 注意：使用super调用的所有属性，

# 都是从MRO列表当前的位置往后找，

# 千万不要通过看代码去找继承关系，一定要看MRO列表)

# 例子

class A():

# q=3

pass

class B(A):

# q=5

pass

class C(A):

q=9

pass

class D(B,C):

# q=15

pass

Q=D()

print(Q.q)

print(D.mro())

组合:

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

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

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

组合描述的是 什么拥有什么的关系 学生 有 书 学生有手机

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

class Person:

def __init__(self, name):

self.name = name

p = Person('perry')

print(p.name)

'''例子'''

class PC:

def open_app(self, app_name):

print('open %s' % app_name)

class Student:

def __init__(self, PC, notebook):

self.PC = PC

self.notebook = notebook

pass

qw=PC()

notebook=PC()

st=Student(qw,notebook)

st.notebook.open_app('学电脑')

菱形继承

# 在py2中 A就是一个经典类

class A:

pass

# 如果你的代码需要兼容py2 那应该显式的继承object 无论是直接还是间接继承

class B(obj):

pass

class A(B):

pass

经典类与新式类

1.只有在python2中才分新式类和经典类，python3中统一都是新式类

2.在python2中，没有显式的继承object类的类，以及该类的子类，都是经典类

3.在python2中，显式地声明继承object的类，以及该类的子类，都是新式类

3.在python3中，无论是否继承object，都默认继承object，即python3中所有类均为新式

​

经典类:

深度优先

新式类:

先深度 直到有一个公共父类时,查找其他路线(基于C3算法)

接口

接口就是一套协议规范

具体表现形式: 有一堆函数 但是只明确了函数的名称 没有明确函数具体实现

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 QW(Test):

def say_hi(self):

print('是 QW ')

q=QW()

q.say_hi()

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

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

鸭子类型

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

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

利用标准库中定义的各种‘与文件类似’的对象，尽管这些对象的工作方式像文件，但他们没有继承内置文件对象的方法

class PC():

def content_device(self,usb_device):

usb_device.open()

usb_device.work()

usb_device.close()

class Mouse:

# 实现接口规定的所有功能

def open(self):

print('mouse open')

def work(self):

print('mouse work')

def close(self):

print('mouse close')

mouse=Mouse()

pc=PC()

pc.content_device(mouse)

class KeyBoard:

def open(self):

print('KeyBoard open')

def work(self):

print('KeyBoard work')

def close(self):

print('KeyBoard close')

key=KeyBoard()

pc.content_device(key)