初识面向对象-接口类、抽象类、封装（设计模式）（四）

接口类
设计模式介绍
http://www.cnblogs.com/tangkaishou/p/9246353.html
http://www.cnblogs.com/luhuajun/p/7442815.html

 # java ： 面向对象编程
# 设计模式 —— 接口
# 接口类 ： python原生不支持
# 抽象类 ： python原生支持的
from abc import abstractmethod,ABCMeta
class Payment(metaclass=ABCMeta): # 元类 默认的元类 type
 @abstractmethod
 def pay(self,money):pass # 没有实现这个方法（来规范全部执行pay方法的代码）
# 规范 ：接口类或者抽象类均可以
# 接口类 支持多继承，接口类中的全部的方法都必须不能实现 —— java（pass位置不能有任何东西，必须是pass）
# 抽象类 不支持多继承，抽象类中方法能够有一些代码的实现 —— 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 pay(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()


 接口类的多继承

（规范代码，接口类自己不实现功能，主要检测接口类里的方法是否所有执行，防止漏掉或使用错误，继承接口类，接口类内方法必须执行） 

# 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

# 接口类 恰好知足接口隔离（好比走、飞等，分开定义）原则 面向对象开发的思想 规范

抽象类

#一切皆文件
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这个概念来解决多继承的规范问题（用Java语法来助于理解python的接口类和抽象类） 

# python
# python中没有接口类 ：
 # python中自带多继承 因此咱们直接用class来实现了接口类
# python中支持抽象类 ： 通常状况下 单继承 不能实例化
 # 且能够实现python代码

多态

# 多态 python 天生支持多态（没有实现多态的机制）
# 像Java必须定义一个父类Payment（无需实现功能），而后子类需继承父类实现多态，好比Alipay、Applepay、pay在Java中必须继承父类，pay才能知道Alipay、Applepay
# 是兄弟，而后实现他们多态

# 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()

# 什么是多态
# python 动态强类型的语言（不能说是强类型语言，在2+‘str’会报错表现出的是强类型，但在list tuple状况无需继承父类来实现多态，表现出的弱类型，因此说python是动态强类型语言）

）
# 鸭子类型
# 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)
#
# # 强类型语言 多态（其余语言）（就像list和tuple，在其余语言必须定义一个父类，List/Tuple/len去继承父类，最后len（I)才不会报错，必须知道他们是兄弟才给不报错）
# # python 语言 鸭子类型（上面的List、len那种方式在python中就是鸭子类型，无需继承父类）

# 接口类和抽象类 在python当中的应用点并非很是必要 
#为何Java中要用接口类和抽象类这种方式去规范，由于Java没鸭子类型。必须经过多态，定义一个父类摆设在那而后去继承来规范
#若是面试问到来解释下设计模式：对于咱们python学习者可能无法很清晰的表达，能够这样来解释，在python中不崇尚采用继承来规范代码，例如list和tuple如此相像的类型都没用继承来规范，觉得崇尚鸭子类型

封装

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

# 狭义上的封装 —— 面向对象的三大特性之一
# 属性 和 方法都藏起来 不让你看见
class Person:
 __key = 123 # 私有静态属性
 def __init__(self,name,passwd):
 self.name = name
 self.__passwd = passwd # 私有属性（在python中定义私有并不由于数据安全，而是为了避免让调用）

 def __get_pwd(self): # 私有方法
 return self.__passwd #只要在类的内部使用私有属性，就会自动的带上_类名

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

alex = Person('alex','alex3714')
alex.__passwd = 1(在外部定义私有方面没用，但会在self插入{‘_passwd’:1}属性，这种定义只能在类的内部是发生）

print(alex._Person__passwd) # _类名__属性名（有这个方式调用私有方式，不要这样调，是不规范的操做）

print(alex.get_pwd())

# 全部的私有 都是在变量的左边加上双下划綫
 # 对象的私有属性
 # 类中的私有方法
 # 类中的静态私有属性
# 全部的私有的 都不能在类的外部使用
在python中没有像Java中的public（公用）/private（私用），python不加双下划线__至关于public，加双下划线__就至关于private

# 昨天的复习和博客
# 今天的做业、复习
# 预习封装的内容




复习

# 接口类 抽象类
# python中没有接口类，有抽象类，abc模块中的metaclass = ABCMeta，@abstructmethod
# 本质是作代码规范用的，但愿在子类中实现和父类方法名字彻底同样的方法
# 在java的角度上看 是有区别的
 # java原本就支持单继承 因此就有了抽象类
 # java没有多继承 因此为了接口隔离原则，设计了接口这个概念，支持多继承了
# python及支持单继承也支持多继承，因此对于接口类和抽象类的区别就不那么明显了
# 甚至在python中没有内置接口类

# 多态和鸭子类型
# 多态 —— python天生支持多态
# 鸭子类型 —— 不依赖父类的状况下实现两个类似的类中的同名方法

# 封装 —— 私有的
# 在python中只要__名字
# 在python中只要__名字，就把这个名字私有化了
# 私有化了以后 就不能能从类的外部直接调用了
# 静态属性 方法 对象属性 均可以私有化
# 这种私有化只是从代码级别作了变形，并无真的约束
# 变形机制 _类名__名字 在类外用这个调用，在类的内部直接__名字调用