python封装函数接口_Python学习笔记25：接口类、抽象类和封装

接口类、抽象类和封装都是和类相关的一些知识概念。

接口类

在说明什么是接口类之前我们先来引入一个问题&＃xff0c;见下

# 假设我们定义了两种支付方式&＃xff0c;分别为支付宝和微信&＃xff0c;

classAlipay:&＃39;&＃39;&＃39;支付宝支付&＃39;&＃39;&＃39;

defpay(self,money):print(&＃39;支付宝支付了%s元&＃39;%money)classApplepay:&＃39;&＃39;&＃39;apple pay支付&＃39;&＃39;&＃39;

defpay(self,money):print(&＃39;apple pay支付了%s元&＃39;%money)ali &＃61; Alipay()

print(ali.pay(100))

apy &＃61; Applepay()

print(apy.pay(100))

# 一般情况下&＃xff0c;为了调用方便&＃xff0c;我们一般会统一一个支付调用的方式&＃xff0c;上面的调用虽然可以解决问题&＃xff0c;但是不方便def pay(payment,money):

&＃39;&＃39;&＃39;

支付函数&＃xff0c;总体负责支付

对应支付的对象和要支付的金额

&＃39;&＃39;&＃39;

payment.pay(money)

p &＃61; Alipay()

pay(p,200)

# 但是当我们又有新的支付方式进来&＃xff0c;而且这些新的支付方式不是同一个人开发的&＃xff0c;在不知道类中的函数名字都是pay命名的时候

# 就容易出错&＃xff0c;如下面这样&＃xff1a;

classAlipay:&＃39;&＃39;&＃39;支付宝支付&＃39;&＃39;&＃39;

defpay(self,money):print(&＃39;支付宝支付了%s元&＃39;%money)classApplepay:&＃39;&＃39;&＃39;apple pay支付&＃39;&＃39;&＃39;

defpay(self,money):print(&＃39;apple pay支付了%s元&＃39;%money)classWechatpay:deffuqian(self,money):&＃39;&＃39;&＃39;实现了pay的功能&＃xff0c;但是名字不一样&＃39;&＃39;&＃39;

print(&＃39;微信支付了%s元&＃39;%money)defpay(payment,money):&＃39;&＃39;&＃39;支付函数&＃xff0c;总体负责支付

对应支付的对象和要支付的金额&＃39;&＃39;&＃39;payment.pay(money)

p&＃61;Wechatpay()

pay(p,200) #此时执行pay函数就会报错&＃xff0c;因为Wechatpay类中的函数不是以pay命名的&＃xff0c;且这种报错不好分析

为了解决这种问题&＃xff0c;可以自己主动设置一个报错机制&＃xff0c;定义一个父类

# 接口初成&＃xff1a;手动报异常&＃xff1a;NotImplementedError来解决开发中遇到的问题

classPayment:defpay(self):raiseNotImplementedErrorclassWechatpay(Payment): # 这里继承了Payment这个类deffuqian(self,money):print(&＃39;微信支付了%s元&＃39;%money)

p&＃61; Wechatpay() #这里不报错

pay(p,200) #这里报错了

可以在继续优化&＃xff0c;写成下面这种形式&＃xff0c;借用abc模块来实现接口

from abc importabstractmethod,ABCMetaclass Payment(metaclass&＃61;ABCMeta): #元类 默认的元类 type&＃xff0c;说明要写一个规范类

&＃64;abstractmethod #装饰器&＃xff0c;作用就是来实现一个规范类&＃xff0c;用来规范子类

def pay(self,money):pass #没有实现这个方法

classWechatpay(Payment):deffuqian(self,money): # 这里修改成pay(self,money)就不会报错了print(&＃39;微信支付了%s元&＃39;%money)

p&＃61; Wechatpay() #不调就报错了,这样在执行这里的就是就报错了&＃xff0c;会告诉哪里出错

实践中&＃xff0c;继承的第一种含义意义并不很大&＃xff0c;甚至常常是有害的。因为它使得子类与基类出现强耦合。

继承的第二种含义非常重要。它又叫“接口继承”。

接口继承实质上是要求“做出一个良好的抽象&＃xff0c;这个抽象规定了一个兼容接口&＃xff0c;使得外部调用者无需关心具体细节&＃xff0c;可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上&＃xff0c;叫做归一化。

内容参考&＃xff1a;https://www.cnblogs.com/Eva-J/articles/7293890.html

接口提取了一群类共同的函数&＃xff0c;可以把接口当做一个函数的集合。

然后让子类去实现接口中的函数。

这么做的意义在于归一化&＃xff0c;什么叫归一化&＃xff0c;就是只要是基于同一个接口实现的类&＃xff0c;那么所有的这些类产生的对象在使用时&＃xff0c;从用法上来说都一样。

归一化&＃xff0c;让使用者无需关心对象的类是什么&＃xff0c;只需要的知道这些对象都具备某些功能就可以了&＃xff0c;这极大地降低了使用者的使用难度。

比如&＃xff1a;我们定义一个动物接口&＃xff0c;接口里定义了有跑、吃、呼吸等接口函数&＃xff0c;这样老鼠的类去实现了该接口&＃xff0c;松鼠的类也去实现了该接口&＃xff0c;由二者分别产生一只老鼠和一只松鼠送到你面前&＃xff0c;即便是你分别不到底哪只是什么鼠你肯定知道他俩都会跑&＃xff0c;都会吃&＃xff0c;都能呼吸。

再比如&＃xff1a;我们有一个汽车接口&＃xff0c;里面定义了汽车所有的功能&＃xff0c;然后由本田汽车的类&＃xff0c;奥迪汽车的类&＃xff0c;大众汽车的类&＃xff0c;他们都实现了汽车接口&＃xff0c;这样就好办了&＃xff0c;大家只需要学会了怎么开汽车&＃xff0c;那么无论是本田&＃xff0c;还是奥迪&＃xff0c;还是大众我们都会开了&＃xff0c;开的时候根本无需关心我开的是哪一类车&＃xff0c;操作手法(函数调用)都一样

#tiger 走路 游泳#swan 走路 游泳 飞#oldying 走路 飞

from abc importabstractmethod,ABCMetaclass Swim_Animal(metaclass&＃61;ABCMeta):

&＃64;abstractmethoddef swim(self):pass #此处的函数只是一个规范&＃xff0c;不执行

class Walk_Animal(metaclass&＃61;ABCMeta):

&＃64;abstractmethoddef walk(self):pass

class Fly_Animal(metaclass&＃61;ABCMeta):

&＃64;abstractmethoddef fly(self):pass

class Tiger(Walk_Animal,Swim_Animal): #这里下面必须要写上上面继承规范类里面的功能

defwalk(self):pass

defswim(self):pass

class OldYing(Fly_Animal,Walk_Animal):pass

class Swan(Swim_Animal,Walk_Animal,Fly_Animal):pass

#接口类 刚好满足接口隔离原则 面向对象开发的思想 规范&＃xff0c;功能应该要隔离开来&＃xff0c;需要哪个功能继承哪个功能

抽像类

import abc #利用abc模块实现抽象类

class All_file(metaclass&＃61;abc.ABCMeta):

all_type&＃61;&＃39;file&＃39;&＃64;abc.abstractmethod#定义抽象方法&＃xff0c;无需实现功能

defread(self):&＃39;子类必须定义读功能&＃39;with open(&＃39;filaname&＃39;) as f:pass&＃64;abc.abstractmethod#定义抽象方法&＃xff0c;无需实现功能

defwrite(self):&＃39;子类必须定义写功能&＃39;

pass

class Txt(All_file): #子类继承抽象类&＃xff0c;但是必须定义read和write方法

defread(self):print(&＃39;文本数据的读取方法&＃39;)defwrite(self):print(&＃39;文本数据的读取方法&＃39;)class Sata(All_file): #子类继承抽象类&＃xff0c;但是必须定义read和write方法

defread(self):print(&＃39;硬盘数据的读取方法&＃39;)defwrite(self):print(&＃39;硬盘数据的读取方法&＃39;)class Process(All_file): #子类继承抽象类&＃xff0c;但是必须定义read和write方法

defread(self):print(&＃39;进程数据的读取方法&＃39;)defwrite(self):print(&＃39;进程数据的读取方法&＃39;)

wenbenwenjian&＃61;Txt()

yingpanwenjian&＃61;Sata()

jinchengwenjian&＃61;Process()#这样大家都是被归一化了,也就是一切皆文件的思想

wenbenwenjian.read()

yingpanwenjian.write()

jinchengwenjian.read()print(wenbenwenjian.all_type)print(yingpanwenjian.all_type)print(jinchengwenjian.all_type)#抽象类 &＃xff1a; 规范#一般情况下 单继承 能实现的功能都是一样的&＃xff0c;所以在父类中可以有一些简单的基础实现&＃xff0c;把一些共同的功能提取出来。#多继承的情况 由于功能比较复杂&＃xff0c;所以不容易抽象出相同的功能的具体实现写在父类中

#抽象类还是接口类 &＃xff1a; 面向对象的开发规范 所有的接口类和抽象类都不能实例化#java &＃xff1a;#java里的所有类的继承都是单继承,所以抽象类完美的解决了单继承需求中的规范问题#但对于多继承的需求&＃xff0c;由于java本身语法的不支持&＃xff0c;所以创建了接口Interface这个概念来解决多继承的规范问题

#python#python中没有接口类 &＃xff1a;接口类可以多继承

#python中自带多继承 所以我们直接用class来实现了接口类&＃xff0c;模拟了Java的接口的概念。#python中支持抽象类 &＃xff1a; 一般情况下 单继承 不能实例化&＃xff0c;因为它是用来抽象出来一个共同的功能

#且可以实现python代码

封装

#广义上面向对象的封装 &＃xff1a;代码的保护&＃xff0c;面向对象的思想本身就是一种#只让自己的对象能调用自己类中的方法

#狭义上的封装 —— 面向对象的三大特性之一#属性 和 方法都藏起来 不让你看见

classPerson:__key &＃61; 123 #私有静态属性

def __init__(self,name,passwd):

self.name&＃61;name

self.__passwd &＃61; passwd #私有属性&＃xff0c;双下划线&＃xff0c;不想让别人调出来看见&＃xff0c;只是代码保护&＃xff0c;并不是保护数据的机制

def __get_pwd(self): #私有方法

return self.__passwd #只要在类的内部使用私有属性&＃xff0c;就会自动的带上_类名,且只有在内部才有私有属性和方法

def login(self): #正常的方法调用私有的方法

self.__get_pwd()

alex&＃61; Person(&＃39;alex&＃39;,&＃39;alex3714&＃39;)print(alex._Person__passwd) #_类名__属性名

print(alex.get_pwd())#所有的私有 都是在变量的左边加上双下划綫

#对象的私有属性

#类中的私有方法

#类中的静态私有属性#所有的私有的 都不能在类的外部使用