0416 抽象类与接口类 多态

一、抽象类和接口类

java 编程原则和设计模式
书：设计模式  程序设计 具有里程碑意义的设计方式 从java中演变出来的
    单例模式：一个类只有一个实例
书：算法导论  计算的方法 时间和空间的问题 权威通用

java
    面向对象
    java不能多继承
编程原则
    python
    开放封闭原则
        开放 对扩展是开放的
        封闭 对修改是封闭的
    依赖倒置原则:高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该应该依赖细节；细节应该依赖抽象。换言之，
要针对接口编程，而不是针对实现编程
已经写完的程序代码是不允许修改的

from abc import abstractmethod    #利用abc模块实现抽象类
class Payment(metaclass=ABCMeta):
    @abstractmethod    #定义抽象方法，制定一个规范，无需实现功能
    def pay(self):pass  '子类必须定义pay功能'
class Alipay(Payment):子类继承抽象类，但是必须定义pay方法
    def pay(self,money):
        print('支付宝')
class Applepay(Payment):
    def pay(self,money):
        print('苹果支付')
def pay(payment,meony):
    payment.pay(meony)
a = Alipay()
b = Applepay()
a.pay(100)　　　　　　#归一化设计：不管是哪一个类的对象，都调用同一个函数去完成相似的功能
pay(a,100)

抽象类和接口类做的事情 ：建立规范
制定一个类的metaclass是ABCMeta，
那么这个类就变成了一个抽象类(接口类)
这个类的主要功能就是建立一个规范

抽象类中所有被abstractmethod装饰的方法都必须被继承的子类实现
如果不实现，那么在实例化阶段将会报错

无论是抽象类还是接口类metaclass=ABCMeta 都不可以被实例化
p = Payment()  # 报错

　接口是Java的概念，java类没有多继承 接口可以实现多继承

python里没有接口的概念

接口隔离原则:使用多个专门的接口，而不使用单一的总接口。即客户端不应该依赖那些不需要的接口。

接口类的作用：
    在java中，能够满足接口隔离原则，且完成多继承的约束
    而在python中，满足接口隔离原则，由于python本身支持多继承，所以就不需要接口的概念了

from abc import abstractmethod
class Fly(metaclass=ABCMeta):
    @abstractmethod
    def fly(self): pass
    @abstractmethod
    def cal_flying_speed(self): pass
    @abstractmethod
    def cal_flying_height(self): pass
class Walk(metaclass=ABCMeta):
    @abstractmethod
    def walk(self): pass
class Swim(metaclass=ABCMeta):
    @abstractmethod
    def swim(self): pass
class Tigger(Walk, Swim):
    def walk(self): pass
    def swim(self): pass
class Monkey(Walk):
    def walk(Fly,): pass
class Swan(Walk,Swim):
    def walk(self): pass
    def swim(self): pass

所有会飞的动物 具有一些会飞的动物的特性
所有会走的动物 具有一些会走的动物的特性

接口类的作用：
    在java中，能够满足接口隔离原则，且完成多继承的约束
    而在python中，满足接口隔离原则，由于python本身支持多继承，所以就不需要接口的概念了

抽象类和接口类
在python中
    并没有什么不同，都是用来约束子类中的方法的
    只要是抽象类和接口类中被abstractmethod装饰的方法，都需要被子类实现
    需要注意的是，当多个类之间有相同的功能也有不同的功能的时候，应该采用多个接口类来进行分别的约束

在java中
    抽象类和接口截然不同
    抽象类的本质还是一个类 是类就必须遵循单继承的规则，所以一个子类如果被抽象类约束，那么它只能被一个父类控制
    当多个类之间有相同的功能也有不同的功能的时候 java只能用接口来解决问题

面试的时候
    抽象类 是python中定义类的一种规范 python本身支持多继承，所以就不需要接口的概念了
    接口  在java中，能够满足接口隔离原则，且完成多继承的约束
在公司类写代码的时候
    如果遇到抽象类 记得按照抽象类中的规范一一实现对应的方法

二、多态与鸭子类型

语言类型：

强类型语言：java c++ c#  数据类型形同才能运算

弱类型语言：shell语言  数据类型形不同也能运算

类型介于 强类型 与 弱类型之间 —— python 动态强语言

import abc
class File(metaclass=abc.ABCMeta): #同一类事物:文件
    @abc.abstractmethod
    def click(self):
        pass

class Text(File): #文件的形态之一:文本文件
    def click(self):
        print('open file')

class ExeFile(File): #文件的形态之二:可执行文件
    def click(self):
        print('execute file')

多态性是指在不考虑实例类型的情况下使用实例
import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

class People(Animal): #动物的形态之一:人
    def talk(self):
        print('say hello')

class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print('say wangwang')

class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print('say aoao')
peo=People()  一个对象的数据类型就是它所在的类
dog=Dog()
pig=Pig()

#peo、dog、pig都是动物,只要是动物肯定有talk方法
#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
peo.talk()
dog.talk()
pig.talk()

#更进一步,我们可以定义一个统一的接口来使用
def func(obj):
    obj.talk()

多态 通过继承实现
    java 在一个类之下发展出来的多个类的对象都可以作为参数传入一个函数或者方法
    在python中不需要刻意实现多态，因为python本身自带多态效果

索引
class list:
    def index(self):pass
class str:
    def index(self):pass
class tuple:
    def index(self):pass
[].index()
''.index()
().index()

鸭子类型
    不是通过具体的继承关系来约束某些类中必须有哪些方法名
    是通过一种约定俗成的概念来保证在多个类中相似的功能叫相同的名字