#适配器模式 Adapter
#概念定义：将一个类的接口转换成客户希望的另一个接口，使得原本不兼容而不能一起工作的类，可以一起工作（接口是用来调用的，比如类的方法）
#适用范围：系统的数据和行为都正确，但是接口不符合，或者两个类做的事情相似，但是具有不同的接口（方法名）
#比如姚明刚去NBA打球，听不懂教练指令，需要一个翻译
class Player:#运动员类
def __init__(self,name):
self.name = name
def attack(self):
print(self.name,'attack（进攻）')
def defense(self):
print(self.name,'defense(防御)')
class Forward(Player):#前锋类
def attack(self):
print('Forward ',self.name,' attack（进攻）')
def defense(self):
print('Forward ',self.name,' defense（防御）')
class Center(Player):#中锋类
def attack(self):
print('Center ',self.name,' attack（进攻）')
def defense(self):
print('Center ',self.name,' defense（防御）')
class ForeignerCenter:#外籍中锋（相当于Adaptee） 不继承Player，它相当于一个功能相似（都有进攻防御）但是接口不同（使用汉字的进攻和防御）
def __init__(self, name):
self.name = name
def 进攻(self): #外籍中锋只认识这个指令
print('外籍中锋 ',self.name,' 进攻')
def 防御(self):
print('外籍中锋 ',self.name,' 防御')
class Translater(Player):#翻译者（相当于适配器类Adapter）
def __init__(self,name):
self.foreignerCenter = ForeignerCenter(name)#这里是关键，把翻译者和外籍中锋关联（Adapter 和 Adaptee关联关系）
def attack(self):
self.foreignerCenter.进攻() #翻译让外籍中锋进攻
def defense(self):
self.foreignerCenter.防御() #翻译让外籍中锋防御
if __name__ == '__main__':
kobe = Forward('Kobe')
kobe.attack()
kobe.defense()
translater = Translater('YaoMing')#这里相当于教练发出的指令，姚明听不懂，但是翻译帮他翻译了
translater.attack()
translater.defense()
#装饰器模式 Decorator
#概念定义：动态的给一个对象添加一些额外的职责，就增加功能而言，装饰模式比生成子类更为灵活
#实现一个Avatar系统（比如qq的个人形象系统），可以穿衣服，甚至脸型，眉毛，秋天要穿秋裤等
#继承是个不可逆的过程，儿子继承了父亲，父亲是不知道有儿子的存在
class Person:
def __init__(self,name):
self.name = name
def dress(self,finery):
self.finery = finery
def show(self):
print('装饰好的',self.name,'他穿了：')
self.finery.show()
class Finery: #服饰类
def show(self):print(' Finery')
class T恤(Finery): #T恤
def show(self):print(' T恤')
class 秋裤(Finery): #秋裤
def show(self):print(' 秋裤')
class 内裤(Finery): #内裤
def show(self): print(' 内裤')
class 袜子(Finery): #袜子
def show(self): print(' 袜子')
class 毛衣(Finery): #毛衣
def show(self): print(' 毛衣')
class 卫裤(Finery): #卫裤
def show(self): print(' 卫裤')
class 鞋子(Finery): # 鞋子
def show(self): print(' 鞋子')
if __name__ == '__main__':
p = Person('李二蛋')
p.dress(内裤())
p.dress(袜子())
p.show() #目前为止虽然做了穿内裤 和穿袜子操作，但是，最终只剩下了穿着袜子满街跑，连片树叶都没遮挡一下，需要改进
#按照装饰器模式 改进版
class Person: #相当于Component，这里把人当做构件
def setName(self,name):
self.name = name
def show(self):
print('装饰好的',self.name,'他穿了：')
class Decorator(Person): #装饰器Decorator（装饰器继承了Person 有点不可思议）
def dress(self,person): #服饰的对象是人，所以要关联人（component）
self.person = person
def show(self):
self.person.show()
class T恤(Decorator): #T恤
def show(self):
super(T恤, self).show()
print(' T恤')
class 秋裤(Decorator): #秋裤
def show(self):
super(秋裤, self).show()
print(' 秋裤')
class 内裤(Decorator): #内裤
def show(self):
super(内裤, self).show()
print(' 内裤')
class 袜子(Decorator): #袜子
def show(self):
super(袜子, self).show()
print(' 袜子')
class 毛衣(Decorator): #毛衣
def show(self):
super(毛衣, self).show()
print(' 毛衣')
class 卫裤(Decorator): #卫裤
def show(self):
super(卫裤, self).show()
print(' 卫裤')
class 鞋子(Decorator): # 鞋子
def show(self):
super(鞋子, self).show()
print(' 鞋子')
if __name__ == '__main__':
p = Person()
p.setName('李二蛋')
nk = 内裤() #这里可以灵活的穿搭，最终实例化的却没有装饰器Decorator类，像是不存在，它的作用就是传递
wz = 袜子()
wk = 卫裤()
tx = T恤()
nk.dress(p) #逐层装饰，dress方法就是装饰的过程
wz.dress(nk)
wk.dress(wz)
tx.dress(wk)
tx.show() #只是没穿秋裤
# 装饰好的 李二蛋 他穿了：
# 内裤
# 袜子
# 卫裤
# T恤
#外观模式 Facade
#概念定义：为子系统的一组接口提供一个一致的界面，此模式定义了一个高层接口，这个接口使得这个子系统更容易使用
#适用范围：子系统的不断重构，复杂性越来越大，可以增加外观Facade，提供一个简单的接口，减少他们之间的依赖，或者在维护遗留的大型系统时候，维护和扩展已经
#非常困难，可以用外观，外观让系统与系统直接的耦合性降低
#1、为复杂的子系统提供简单的接口
#2、在客户端和抽象的实现类中存在许多依赖关系
#3、想要对子系统进行分层
#比如客户关注多只股票，需要花更多的经理，不如，买1个包含这些股票的基金
#代理模式 Proxy
#概念定义：为其他对象提供一种代理以控制对这个对象的访问
#适用范围：1、远程代理，为一个对象再不同地址空间提供局部代表
#2、虚拟代理，根据需要创建开销很大的对象。通过它来存放实例化需要很长时间的真实对象。
#秀才让小六代他像郭芙蓉求婚
class Person:
def __init__(self,name):
self.name = name
class Girl(Person):pass
class Wooer(Person): #追求者
def woo(self,girl): #开始追求
print(self.name,'说：嫁给我吧！',girl.name)
if __name__ == '__main__':
girl = Girl('郭芙蓉')
wooer = Wooer('秀才')
wooer.woo(girl) #秀才 说：嫁给我吧！ 郭芙蓉 这样肯定不行，秀才要让小六代替他求婚
#改进
class IWoo: #求爱接口
def woo(self):print('嫁给我吧！')
class Girl:
def setName(self,name):
self.name = name
class Wooer(IWoo): #追求者 实现求爱接口
def __init__(self,girl):
self.girl = girl
def woo(self):
print('嫁给我吧！',self.girl.name)
class Proxy(IWoo): #代理 实现求爱接口
def __init__(self,girl):
self.wooer = Wooer(girl)
def woo(self): # 开始追求
print('代理说：')
self.wooer.woo()
if __name__ == '__main__':
girl = Girl()
girl.setName('郭芙蓉')
# wooer = Wooer('秀才') #这里（client端）不用实例化秀才，main全程没看到秀才，郭芙蓉就可以认为是代理（小六）向她求婚，
# 实际上，代理Proxy内部，已经告知了秀才（实例化了秀才），并且求爱（Woo方法）的时候使用的是秀才的操作
proxy = Proxy(girl)
proxy.woo()
