# 接口类：python 原生不支持
# 抽象类：python 原生支持的
接口类
首先我们来看一个支付接口的简单例子
from abc import abstractmethod,ABCMeta #我们也可以创建一个规范类
class Payment(metaclass=ABCMeta): # 元类 默认的元类 type
@abstractmethod
def pay(self,money):
raise Notlmplemented #规范类要求需要实现一个 叫做 pay 的方法
#这样在不调用的情况下 就会抛出错误 在实例化时就可以发现这个问题 # 规范 ：接口类或者抽象类都可以
# 接口类 支持多继承，接口类中的所有的方法都必须不能实现 —— java
# 抽象类 不支持多继承，抽象类中方法可以有一些代码的实现 —— java class Payment:
def pay(self,money): #2.没有实现该方法，就会抛出这个异常,用来隐藏 1 处的错误
raise Notlmplemented #原理就是 如果不实现 pay 方法 就会抛出这个报错
#报错如下
#NameError: name 'Notlmplemented' is not defined class Weipay(Payment):
def pay(self,money):
print('微信支付了%s元'%money) class Alipay(Payment):
def pay(self,money):
print('支付宝支付了%s元'%money) class Apppay(Payment):
def pays(self,money): #1.如果这里的 pay 换成了其他名字就会报错 与下面的 pay 函数冲突了
print('苹果支付了%s元'%money)
wei = Weipay()
ali = Alipay()
app = Apppay() def pay(pay_obj,money):
pay_obj.pay(money) pay(wei,100)
pay(ali,100)
pay(app,100)
#weipay.pay(100)
#alipay.pay(100)
接口类的多继承
这是三种动物
tiger 走路 游泳
swan 走路 游泳 飞
oldying 走路 飞
为了避免代码重复，我们写以下三个类
下面就是实现了 接口类的规范 不需要有功能实现的代码
#下面就是实现了 接口类的规范 不需要有功能实现的代码
from abc import abstractmethod,ABCMeta
class Swim_Animal(metaclass=ABCMeta):
@abstractmethod
def swim(self):pass class Walk_Animal(metaclass=ABCMeta):
@abstractmethod
def walk(self):pass class Fly_Animal(metaclass=ABCMeta):
@abstractmethod
def fly(self):pass #继承了类里面的相应的方法就必须要写
class Tiger(Walk_Animal,Swim_Animal):
def walk(self):
pass
def swim(self):
pass
class OldYing(Fly_Animal,Walk_Animal):pass
class Swan(Swim_Animal,Walk_Animal,Fly_Animal):pass # 这样就完了 接口类 刚好满足接口隔离原则 面向对象开发的思想 规范
python 中没有接口类 这个只是类似，就是说 我要实现不同的功能，我就去继承不同的接口，来规范我当前类中要用那些函数
好了我们接下来稍稍完善下上满的例子
from abc import abstractmethod,ABCMeta
class Swim_Animal(metaclass=ABCMeta):
@abstractmethod
def swim(self):pass class Walk_Animal(metaclass=ABCMeta):
@abstractmethod
def walk(self):pass class Fly_Animal(metaclass=ABCMeta):
@abstractmethod
def fly(self):pass class Tiger(Walk_Animal,Swim_Animal):
def walk(self,num):
print('狮子跑了 %s 公里'%num)
def swim(self,num):
print('狮子游了 %s 公里'%num) class OldYing(Fly_Animal,Walk_Animal):
def fly(self,num):
print('老鹰飞了 %s 公里'%num)
def walk(self,num):
print('老鹰跑了 %s 公里'%num) class Swan(Swim_Animal,Walk_Animal,Fly_Animal):
def fly(self,num):
print('天鹅飞了 %s 公里'%num)
def walk(self,num):
print('天鹅跑了 %s 公里'%num)
def swim(self,num):
print('天鹅游了 %s 公里'%num) T = Tiger()
o = OldYing()
s = Swan()
#s.fly(5) def action(action_obj,num):
action_obj(num) action(s.fly,5)
抽象类
如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性
在 python 中实现抽象类，抽象类一般是单继承
操作系统一切皆文件
我们来实现一个抽象类
import abc #利用 abc 模块实现抽象类 class All_file(metaclass=abc.ABCMeta):
all_type='file'
@abc.abstractmethod #定义抽象方法，无需实现功能
def read(self):
'子类必须定义读功能'
with open('filaname') as f:
pass @abc.abstractmethod #定义抽象方法，无需实现功能
def write(self):
'子类必须定义写功能'
pass class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
def read(self):
print('文本数据的读取方法')
def write(self):
print('文本数据的读取方法') class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
def read(self):
print('硬盘数据的读取方法') def write(self):
print('硬盘数据的读取方法') class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
def read(self):
print('进程数据的读取方法') def write(self):
print('进程数据的读取方法') wenbenwenjian=Txt() yingpanwenjian=Sata() jinchengwenjian=Process() #这样大家都是被归一化了,也就是一切皆文件的思想
wenbenwenjian.read()
yingpanwenjian.write()
jinchengwenjian.read() print(wenbenwenjian.all_type)
print(yingpanwenjian.all_type)
print(jinchengwenjian.all_type)
抽象类 ： 规范
一般情况下 单继承 能实现的功能都是一样的，所以在父类中可以有一些简单的基础实现
多继承的情况 由于功能比较复杂，所以不容易抽象出相同的功能的具体实现写在父类中
抽象类还是接口类 ： 面向对象的开发规范 所有的接口类和抽象类都不能实例化
java：
java里的所有类的继承都是单继承,所以抽象类完美的解决了单继承需求中的规范问题
但对于多继承的需求，由于java本身语法的不支持，所以创建了接口Interface这个概念
来解决多继承的规范问题
python：
python中没有接口类 ：
python中自带多继承 所以我们直接用class来实现了接口类
python中支持抽象类 ： 一般情况下 单继承 不能实例化（接口类抽象类）
且可以实现python代码
多态
python 天生支持多态，python 是动态强类型的语言
多态指的是一类事物有多种形态
动物有多种形态：人，狗，猪
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') People().talk()
文件有多种形态：文本文件，可执行文件
多态性
什么是多态动态绑定（在继承的背景下使用时，有时也称为多态性）
多态性是指在不考虑实例类型的情况下使用实例
在面向对象方法中一般是这样表述多态性：
向不同的对象发送同一条消息（ ！！！obj.func():是调用了obj的方法func，又称为向 obj 发送了一条消息 func ），不同的对象在接收时会产生不同的行为（即方法）。 也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。 比如：老师.下课铃响了（），学生.下课铃响了()，老师执行的是下班操作，学生执行的是放学操作，虽然二者消息一样，但是执行的效果不同
鸭子类型
# 鸭子类型
# list tuple 如果说两个类型为鸭子类型 就是说这两个类型很相识
# 不崇尚根据继承所得来的相似
# 我只是自己实现我自己的代码就可以了。
# 如果两个类刚好相似，并不产生父类的子类的兄弟关系，而是鸭子类型
# list tuple 这种相似，是自己写代码的时候约束的，而不是通过父类约束的
# 优点：松耦合 每个相似的类之间都没有影响
# 缺点：太随意了,只能靠自觉
# 接口类和抽象类 在 python 当中的应用点并不是非常必要
封装
# 广义上面向对象的封装 ：代码的保护，面向对象的思想本身就是一种
# 只让自己的对象能调用自己类中的方法
# 狭义上的封装 —— 面向对象的三大特性之一
# 属性 和 方法都藏起来 不让你看见
class Person:
__key = 123 # 私有静态属性
def __init__(self,name,passwd):
self.name = name
#self.passwd = passwd
self.__passwd = passwd #当属性前面加上 __ 就成为了私有属性 def get_pwd(self): #在类的内部使用方法调用 __passwd 属性
print(self.__dict__)
return self.__passwd #只要在类的内部使用私有属性，就会自动的带上_类名 def __login(self): #私有方法
self.__get.pwd() per = Person('ysg','')
#print(alex.passwd)
#print(per.__passwd) #然后就找不到该属性了
print(per.__dict__) #这里还是可以看到 所有私有属性并不是约束数据安全的只是在代码级别加了一层密
print(per._Person__passwd) # _类名__属性名 这样调用就可以了 不过不应该去调取
print(per.get_pwd()) print(per.__login) #调取不到
#定义类的私有属性 只能在类的内部 外部就不可以
per.__high = 1
print(per.__high) #外部就可以直接使用
所有的私有 都是在变量的左边加上双下划线
对象的私有属性
类中的私有方法
类中的静态私有属性
所有的私有的 都不能在类的外部使用
封装之隐藏
如何隐藏：在 python 中用双下划线开头的方式将属性隐藏起来（设置成私有的）
class A:
__x = 1 def __init__(self, name):
self.name = name def __foo(self):
print('this is foo') #print(A.__x)
# AttributeError: type object 'A' has no attribute '__x'
a = A('ysg')
print(a.name) # ysg
#print(A.__foo) #AttributeError: type object 'A' has no attribute '__foo' # 我们来查看下 class A 的属性
# 可以看到并没有 __x、__foo 的属性，但有了 _A__x、_A__foo 的属性
print(A.__dict__) #{'__module__': '__main__', '_A__x': 1, '__init__': <function A.__init__ at 0x000001D63A0602F0>, '_A__foo': <function A.__foo at 0x000001D63A0BB268>,,...}
如上，我们可以大胆的猜测一下，当我们使用双下划线隐藏后，它可能做了某种变形，我们来尝试下
print(A._A__x) # 1
print(A._A__foo) # <function A.__foo at 0x000001D26E09D1E0>
可以看出，的确是做了变形的处理
接下来看下它有哪些特点：
- 类中定义的 __x 只能在内部使用，如 self.__x，引用的就是变形的结果
- 这种变形其实正是针对外部的变形，在外部无法通过 __x 这个名字访问到
- 在子类定义的 __x 不会覆盖在父类定义的 __x，因为子类中变形成了：_子类名__x，而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的
这种变形需要注意的问题是：
- 这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N
- 变形的过程只在类的定义是发生一次,在定义后的赋值操作，不会变形
- 在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的
我们用一个例子来验证下
class B:
def __foo(self):
print('B.foo') def bar(self):
print('B.bar')
self.__foo() class C(B):
def __foo(self):
print('C.foo') c = C()
c.bar() # 结果：
B.bar
B.foo
封装不是单纯意义的隐藏
1.封装数据属性：明确区分内外，控制外部对隐藏属性的操作
将数据隐藏起来这不是目的。隐藏起来然后对外提供操作该数据的接口，然后我们可以在接口附加上对该数据操作的限制，以此完成对数据属性操作的严格控制
我们来写一个例子
class People:
def __init__(self, name, age):
self.__name = name
self.__age = age def tell_info(self):
print('Name:<%s>\nAge:<%s>' % (self.__name, self.__age)) def set_info(self, name, age):
if not isinstance(name, str):
print('名字必须是字符串类型')
return
if not isinstance(age, int):
print('年龄必须是 int 类型')
return
self.__name = name
self.__age = age p = People('ysg', 16)
p.tell_info()
# Name:<ysg>
# Age:<16> p.set_info(123, 18) # 名字必须是字符串类型
p.tell_info()
p.set_info('er', '18') # 年龄必须是 int 类型
p.tell_info()
# Name:<ysg>
# Age:<16> p.set_info('er', 18)
p.tell_info()
# Name:<er>
# Age:<18>
上面可以看到：
tell_inso() 实现了在不能直接查看属性时，开一个接口且按照一定的规格进行查看属性
set_info() 实现了在不能直接修改属性时，开一个接口且对传来的属性进行判断，通过则进行修改
2.封装方法：隔离复杂度
我们来看下面的例子
1.取款是功能,而这个功能有很多功能组成:插卡、密码认证、输入金额、打印账单、取钱
2.对使用者来说,只需要知道取款这个功能即可,其余功能我们都可以隐藏起来,很明显这么做
3.隔离了复杂度,同时也提升了安全性class ATM:
def __card(self):
print('插卡') def __auth(self):
print('用户认证') def __input(self):
print('输入取款金额') def __print_bill(self):
print('打印账单') def __take_money(self):
print('取款') # 实现了只通过这一个接口来完成上面流程的调用
def withdraw(self):
self.__card()
self.__auth()
self.__input()
self.__print_bill()
self.__take_money() a = ATM()
a.withdraw()
注意：在编程语言里，对外提供的接口（接口可理解为了一个入口），可以是函数，称为接口函数，这与接口的概念还不一样，接口代表一组接口函数的集合体
封装与可扩展性
封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑
class Room:
def __init__(self,name,owner,weight,length,height):
self.name=name
self.owner=owner # 这里访问者其实是要结果，值可以隐藏起来
self.__weight=weight
self.__length=length
self.__height=height #在这里改变运算规则
def tell_area(self):
return self.__weight * self.__length * self.__height r=Room('卫生间','alex',10,10,10) # print(r.tell_area()) #用户调用方式不变
print(r.tell_area())
达到了：对外提供的接口中，隐藏了内部的实现细节；扩展了功能，但不需要改变调用的方法