一. 接口类
java：面向对象编程
设计模式 -- 接口类
接口类：python原生不支持
抽象类：python 原生支持的
from abc import abstractclassmethod,ABCMeta
class Payment(metaclass= ABCMeta): # 元类，默认元类：type
@abstractclassmethod
def pay(self, money):
raise NotImplemented # 没有实现这个方法
# Payment 规范：接口类/抽象类
# 一般使用多继承了，就用接口类
# 接口类中的所有方法都必须不能实现 -- Java
# 抽象类不支持多继承
# 抽象类中可以有一些代码的实现 -- Java
class Wechat(Payment):
def pay(self, money):
print('已经使用微信支付了%s元'%money)
class Alipay(Payment):
def pay(self,money):
print('已经使用支付宝支付了%s元' % money)
def pay(pay_obj, money): # 统一支付入口
pay_obj.pay(money)
class Applepay(Payment):
def pay(self, money):
print('已经使用applepay支付了%s元' % money)
wechat = Wechat()
# wechat.pay(100)
ali = Alipay()
# ali.pay(200)
app = Applepay()
# app.fuqian(199)
pay(wechat,100)
pay(ali,100)
pay(app,199)
tiger：走路，游泳 # 老虎
swan：走路，游泳，飞 # 天鹅
oldying：走路，飞 # 老鹰
from abc import abstractclassmethod,ABCMeta
class Swim_Animal(metaclass=ABCMeta):
@abstractclassmethod
def swim(self):
pass
class Walk_Animal(metaclass=ABCMeta):
@abstractclassmethod
def walk(self):
pass
class Fly_Animal(metaclass=ABCMeta):
@abstractclassmethod
def fly(self):
pass
class Tiger(Walk_Animal, Swim_Animal):
def walk(self):
pass
def swim(self):
pass
class Swan(Walk_Animal, Swim_Animal, Fly_Animal):
def walk(self):
pass
def swim(self):
pass
def fly(self):
pass
class Oldying(Walk_Animal, Fly_Animal):
def walk(self):
pass
def fly(self):
pass
# 接口类
# 原则：接口隔离原则：使用多个专门的接口，而不是使用单一的总接口，即客户端不应该依赖那些不需要的接口
# 面向对象开发的思想、规范
二. 抽象类
# 一切皆文件
import abc #利用abc模块实现抽象类
class All_file(metaclass=abc.ABCMeta):
all_type='file'
@abc.abstractmethod #定义抽象方法，无需实现功能
def read(self):
'子类必须定义读功能'
with open('fileName') as f:
pass
@abc.abstractmethod #定义抽象方法，无需实现功能
def write(self):
'子类必须定义写功能'
pass
class Txt(All_file):
pass
t1=Txt() #报错,子类没有定义抽象方法
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)
抽象类：规范
一般情况下，是单继承，能实现的功能都是一样的 ，所以在父类中可以有一些简单的基础实现
多继承的情况，由于功能比较复杂，所以不容易抽象出相同的功能的具体实现 写在父类中
不管是抽象类还是接口类：都是面向对象的开发规范
python中没有接口类。在Java中，有接口interface这个概念，是因为Java中不支持多继承。
python中自带多继承，所以我们直接用class来实现了接口类
python中支持抽象类： 一般情况下为 单继承 ，且可以实现python代码
接口类和抽象类都不能实现实例化
Java：
java里的所有类的继承都是单继承，所以抽象类完美的解决了单继承需求中的规范问题
但对于多继承的需求，由于Java本身语法的不支持，所以创建了接口interface这个概念来解决多继承的问题。
三. 多态
其他语言中：
def func(int num, str name):
pass
func(2,'alex')
class Payment():pass
class Alipay(Payment):
def pay(self,money):
print('已经使用支付宝支付了%s元' % money)
def pay(Payment pay_obj, int money):
pay_obj.pay(money)
class Applepay(Payment):
def pay(self, money):
print('已经使用applepay支付了%s元' % money)
实现了多态
什么是多态？
多态指的是一类事物有多种形态
文件有多种形态：文本文件，可执行文件
动物有多种形态：人，狗，猪
python崇尚 鸭子类型
list tuple
class foo:
def slice(self):pass
def index(self):pass
class list(foo):
def slice(self):pass
def index(self):pass
class tuple(foo):
def slice(self):pass
def index(self):pass
鸭子类型不崇尚根据继承所得来的相似
而是只是自己实现自己的代码就可以了
如果两个类刚好相似，并不产生父类的子类的兄弟关系，而是鸭子类型
list tuple 这种相似，是自己写代码的时候约束的，而不是通过父类约束的
优点：松耦合 （每个相似的类之间都没有影响）
缺点：太随意了，只能靠自觉
接口类和抽象类在python中的应用点并不是非常必要
四. 封装
广义上面向对象的封装：代码的保护，面向对象的思想本身就是一种封装
只让自己的对象能调用自己类中的方法
狭义上的封装 -- 面向对象的三大特性之一
把 属性 和 方法 都藏起来 ，不让你看见
class Person:
__key = 123 # 私有的静态属性
def __init__(self,name, password):
self.name = name
self.__password = password # 私有属性：前面加上双下划线
def __get_pwd(self): # 私有方法
print(self.__dict__)
return self.__password # 只要在类的内部使用私有属性，就会自动的带上_类名
def login(self): # 正常的方法调用私有的方法
self.__get_pwd()
alex = Person('alex','alex3714')
# print(alex.__password)
print(alex.__dict__) # {'name': 'alex', '_Person__password': 'alex3714'}
# print(alex._Person__password) # alex3714 可以这样调，但不能这么用（_类名__属性名）
alex.__high = 1
print(alex.get_pwd()) # {'name': 'alex', '_Person__password': 'alex3714', '__high': 1}
print(alex.__high)
所有的私有，都是在变量的左边加上双下划线
对象的私有属性
类中的私有方法
类中的静态属性
所有的私有的，都不能在类的外部使用