设计模式应用

设计模式应用

一、一对多关系

1、观察者

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

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、工厂模式

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

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：为了减少简单工厂类里面的逻辑判断，可以采用“反射”机制，直接根据外部的配置文件读取出需要使用产品类的信息。

 

一对一

适配器模式

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

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

用字典的方法作为映射，一级一级汇总。

+ View Code?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

#-*- 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 这样就能路由到想要应用的函数了。