设计模式应用
设计模式应用
一、一对多关系
1、观察者
class Person(object):
def __init__(self,name):
self.name = name
class Sentry(Person):
def __init__(self,name):
super(Sentry,self).__init__(name)
self.perlist = []
def treebanch(self,objs):
self.perlist.append(objs)
def warning(self):
for odj in self.perlist:
odj.action()
class Lian1(Person):
def __init__(self,name):
super(Lian1,self).__init__(name)
def action(self):
print "lian1 running"
class Lian2(Person):
def __init__(self,name):
super(Lian2,self).__init__(name)
def action(self):
print "lian2 jump"
class Gun():
def paohong(self):
print 'paohong'
gun = Gun()
lian1 = Lian1('1lian')
lian2 = Lian2('2lian')
sentry = Sentry('s')
sentry.treebanch(lian1)
sentry.treebanch(lian2)
gun.paohong()
sentry.warning()
2、工厂模式
class Addoper():
def getResult(self):
return self.r1 + self.r2
class Suboper():
def getResult(self):
return self.r1 - self.r2
class Muloper():
def getResult(self):
return self.r1 * self.r2
class Divoper():
def getResult(self):
return self.r1/self.r2
class Factoryoper(object):
def __init__(self):
self.oper_map = {}
self.oper_map['+']=Addoper()
self.oper_map['-']=Suboper()
self.oper_map['*']=Muloper()
self.oper_map['//']=Divoper()
def createOper(self,guide):
return self.oper_map[guide]
factory = Factoryoper()
o1 = raw_input("a:")
o2 = raw_input("b:")
op = raw_input("operant:")
product = factory.createOper(op)
product.r1 = int(o1)
product.r2 = int(o2)
r = product.getResult()
print r
定义加减运算类的时候不用将待处理的数据设置在 __init__中，而是在环境中赋值，就能完成操作。好处是工厂类中不用去关心调用一个操作类定义对象时，要输入什么数值。
总结：以上两种方法都是一个激励过来后，有一个响应源做出反应，然后传达给各个单元。
关系定义（环境）：都是先由响应源收集单元，触发单元变化。
3 抽象工厂模式
抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
优点：易于交换“产品系列”，只要更改相应的工厂即可。
缺点：建立产品的时候很繁琐，需要增加和修改很多东西。
优化1：为了避免客户端有过多的逻辑判断，可以封装出一个简单工厂类来生成产品类。
优化2：为了减少简单工厂类里面的逻辑判断，可以采用“反射”机制，直接根据外部的配置文件读取出需要使用产品类的信息。
一对一
适配器模式
class Computer():
def connectScreen8(self,screen):
print "connect screen Screen8"
screen.screen8()
class Screen16():
def connector(self):
print "computer connect"
class Adapt():
def __init__(self):
self.screen16obj = Screen16()
def screen8(self):
print "to screen------------"
self.screen16obj.connector()
c = Computer()
screen = Screen16()
a = Adapt()
c.connectScreen8(a)
树状机构，抽象工厂方法
入口 接收入参
抽象工厂方法1 抽象工厂2
工厂1 工厂2 工厂2.1
产品1 产品2 产品2.1
用字典的方法作为映射，一级一级汇总。
#-*- coding:utf-8 -*-
__author__ = 'lWX330844'
class Car():
def advantage(self):
print "running"
def __str__(self):
return "it is a car"
class Carwh():
def speed(self):
print "two wh"
class Truck():
def speed(self):
print "four wh"
class Truckwh():
def advantage(self):
print "weight"
def __str__(self):
return "it is a Truck"
class FactoryCar():
def __init__(self):
self.productmap = {"Car":Car,"Carwh":Carwh}
class FactoryTruck():
def __init__(self):
self.productmap = {"Truck":Truck,"Truckwh":Truckwh}
class Product():
def __init__(self):
self.factorymap = {"car":FactoryCar,"truck":FactoryTruck}
dingdan = "car"
prod = Product()
print prod.factorymap[dingdan]().productmap["Car"]()
prod.factorymap[dingdan]().productmap["Car"]().advantage()
当然在实际的应用中也可以使用文件结构的形式，来一级一级找到路由。
a文件夹/
__init__.py
bench文件夹
__init__.py
USA文件夹/
__init__.py
U.py
在__init__.py文件中引用from bench.USA import U 这样就能路由到想要应用的函数了。
