面向对象的三大特性:封装、继承、抽象---->抽象、多态、接口、封装 第二十天 2018.11.5
上节复习:
组合:什么有什么
继承:什么是什么的关系
单继承 *****
先抽象再继承，几个类之间的相同代码抽象出来，成为父类
子类自己没有的名字，就可以使用父类的方法和属性
如果子类自己有，一定是先用自己的
在类中使用self的时候，一定要看清楚self指向谁
多继承 ***
新式类和经典类：
多继承寻找名字的顺序 ： 新式类广度优先，经典类深度优先
新式类中 有一个类名.mro方法，查看广度优先的继承顺序
python3中 有一个super方法，根据广度优先的继承顺序查找上一个类
接口类、抽象类：
java ： 面向对象编程
设计模式 —— 接口
接口类 ： python原生不支持
抽象类 ： python原生支持的
规范类Payment要求下面子类实现pay方法
必须指定元类是ABCMeta;必须对函数加装饰器
元类(metaclass) 默认的元类 type---->指定元类
要想在Python中创建一个类，需要有一个机制支持创建这个类，元类就是这个机制
装饰器---->只需要实例化一下就可以知道代码中的异常
规范 ：接口类或者抽象类都可以(规范子类)
接口类 支持多继承，接口类中的所有的方法都必须不能实现 —— java
抽象类 不支持多继承，抽象类中方法可以有一些代码的实现 —— java
from abc import abstractmethod,ABCMeta
#规范类Payment要求下面子类实现pay方法
#必须指定元类是ABCMeta;必须对函数加装饰器
class Payment(metaclass=ABCMeta): # 元类(metaclass) 默认的元类 type---->指定元类
#要想在Python中创建一个类，需要有一个机制支持创建这个类，元类就是这个机制
@abstractmethod # 装饰器---->只需要实例化一下就可以知道代码中的异常
def pay(self,money):pass # 没有实现这个方法
# 规范 ：接口类或者抽象类都可以(规范子类)
# 接口类 支持多继承，接口类中的所有的方法都必须不能实现 —— java
# 抽象类 不支持多继承，抽象类中方法可以有一些代码的实现 —— java
class Wechat(Payment):
def pay(self,money):
print('已经用微信支付了%s元'%money)
class Alipay(Payment):
def pay(self,money):
print('已经用支付宝支付了%s元' % money)
class Applepay(Payment):
def fuqian(self,money): #报错
print('已经用applepay支付了%s元' % money)
def pay(pay_obj,money): # 统一支付入口
pay_obj.pay(money) #报错
# wechat = Wechat()
# ali = Alipay()
app = Applepay()
# wechat.pay(100)
# ali.pay(200)
p = Payment()
pay(Alipay,200)
pay(Wechat,100)
pay(Applepay)
接口类的多继承
接口隔离原则:使用多个专门的接口，而不使用单一的总接口。即客户端不应该依赖那些不需要的接口。
# 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):
def walk(self):
pass
def fly(self):
pass
class Swan(Swim_Animal,Walk_Animal,Fly_Animal):
def walk(self):
pass
def swim(self):
pass
def fly(self):
pass
继承了类里面相应的方法，就必须要写出
接口类 刚好满足接口隔离原则 面向对象开发的思想 规范
抽象类:
操作系统中:一切皆文件
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代码(Java实现代码就报错)
多态 python 天生支持多态
Python对传入数据类型不明显,比如Java传入参数时会指定传入数据类型(多态必须传入父类数据类型)
Python传入参数时不需要指定数据类型
多态一类事物的多个形态
传入参数指定传入数据类型：
def func(int num,str name):
pass
func('alex',2)
class Payment:pass
鸭子类型:
支付的多态:
class Alipay():
def pay(self,money):
print('已经用支付宝支付了%s元' % money)
class Applepay():
def pay(self,money):
print('已经用applepay支付了%s元' % money)
def pay(pay_obj,money): # 统一支付入口 归一化设计
pay_obj.pay(money)
pay()
什么是多态
Java必须要借助父类才可以实现多态
Python不需要借助任何，可以直接实现多态
python 动态强类型的语言(某些地方表现的和强类型语言不一致)
传参时不需要指定数据类型---->弱类型
2+str---->报错，强类型
鸭子类型(list tuple)
不崇尚根据继承所得来的相似
我只是自己实现我自己的代码就可以了。
如果两个类刚好相似，并不产生父类的子类的兄弟关系，而是鸭子类型
list tuple 这种相似，是自己写代码的时候约束的，而不是通过父类约束的
优点 ： 松耦合 每个相似的类之间都没有影响
缺点 ： 太随意了,只能靠自觉
鸭子类型:
class List():
def __len__(self):pass #两个类都实现了同样的方法
class Tuple():
def __len__(self):pass
def len(obj): #可以用一个函数同时调用两个类
return obj.__len__()
l = Tuple()
len(l) #所以可以用一个函数调用
# 强类型语言 多态(不用多态，不指定传入数据类型就报错)
# python 语言 鸭子类型
接口类和抽象类 在python当中的应用点并不是非常必要
解释设计模式接口类...
在Python里面我们不崇尚使用继承的方式进行规范，list和tuple这么相似的两个数据类型都没有使用继承
Python崇尚鸭子类型，不崇尚采用继承的形式去规范代码
Python和Java是有区别的，他们的编程方式不同
Java里面有些语言特点导致有很多适合Java的设计模式和编程方式
对于Python来说并不完全适用，Python没Java拥有的有些特性，Python中不需要进行那些约束
广义上面向对象的封装 ：代码的保护，面向对象的思想本身就是一种封装
只让自己的对象能调用自己类中的方法
狭义上的封装 —— 面向对象的三大特性之一
属性 和 方法都藏起来 不让你看见
class Person:
__key = 123 # 私有静态属性
def __init__(self,name,passwd):
self.name = name
self.__passwd = passwd # 私有属性
def __get_pwd(self): # 私有方法
return self.__passwd #只要在类的内部使用私有属性，就会自动的带上_类名
def login(self): # 正常的方法调用私有的方法
self.__get_pwd()
alex = Person('alex','alex3714')
print(alex._Person__passwd) # _类名__属性名
print(alex.get_pwd())
浙公网安备 33010602011771号