访问者模式
我觉得visitor模式是在补修改已有程序结构前提下，通过添加额外的访问者完成对代码功能的拓展 为什么这样用？当你的类层次较多，在某层结构中增加新的方法，要是在基类上面添加或者变更，可能破坏原来的设计， 有兼容问题，所以只在需要的类上面动态添加。
python的例子
这里是个构建车的例子，每个部件都有一个accept的方法接受我上面说的所谓’访问者’，而这个访问者 以参数的方式传进来，但是其实他是一个含有一些功能的类的实例，它拥有很多个visit开头的方法对应不同的部件。 这样就不需要修改这些部件，而只是修改我们的访问者类的相关部分。
# 轮子,引擎, 车身这些定义好了都不需要变动
class wheel:
def __init__(self, name):
self.name = name
def accept(self, visitor):
# 每个visitor是同样的，但是其中的方法是不一样的，比如这里是visitwheel，
# 然后传入了self，想想？他其实想做什么就能做什么
visitor.visitwheel(self)
class engine:
def accept(self, visitor):
visitor.visitengine(self)
class body:
def accept(self, visitor):
visitor.visitbody(self)
# 我们要组合成车
class car:
def __init__(self):
self.engine = engine()
self.body = body()
self.wheels = [ wheel(“front left”), wheel(“front right”),
wheel(“back left”) , wheel(“back right”) ]
# 这个也不需要在动，他只是上面部件的组合，只是做了属性的委托
def accept(self,visitor):
visitor.visitcar(self)
self.engine.accept(visitor)
self.body.accept(visitor)
for wheel in self.wheels:
wheel.accept(visitor)
# 这个才是我们的访问者，每次的修改都在这里面
class printvisitor:
def visitwheel(self, wheel):
print “visiting “+wheel.name+” wheel”
def visitengine(self, engine):
print “visiting engine”
def visitbody(self, body):
print “visiting body”
def visitcar(self, car):
print “visiting car”
if __name__ == ‘__main__’:
car = car()
visitor = printvisitor()
car.accept(visitor)
观察者模式
当我们希望一个对象的状态发生变化，那么依赖与它的所有对象都能相应变化(获得通知),那么就可以用到observer模式， 其中的这些依赖对象就是观察者的对象，那个要发生变化的对象就是所谓’观察者’
python的例子
# 这个是观察者基类
class subject(object):
def __init__(self):
self._observers = []
# 添加依赖的对象
def attach(self, observer):
if not observer in self._observers:
self._observers.append(observer)
# 取消添加
def detach(self, observer):
try:
self._observers.remove(observer)
except valueerror:
pass
# 这里只是通知上面注册的依赖对象新的变化
def notify(self, modifier=none):
for observer in self._observers:
# 可以设置过滤条件，对不符合过滤条件的更新
if modifier != observer:
observer.update(self)
# 观察者类
class data(subject):
def __init__(self, name=”):
super(data, self).__init__()
self.name = name
self._data = 0
# python2.6新增的写法,获取属性为property，设置属性为(假设属性名字为x)@x.setter,删除为@x.deleter
@property
def data(self):
return self._data
@data.setter
def data(self, value):
self._data = value
self.notify()
# 这里有2个被观察者，也就是依赖的对象，每次data有改变，这2个view都会变动
class hexviewer(object):
def update(self, subject):
print ‘hexviewer: subject %s has data 0x%x’ % (subject.name, subject.data)
class decimalviewer(object):
def update(self, subject):
print ‘decimalviewer: subject %s has data %d’ % (subject.name, subject.data)
if __name__ == ‘__main__’:
data1 = data(‘data 1’)
data2 = data(‘data 2’)
view1 = decimalviewer()
view2 = hexviewer()
data1.attach(view1)
data1.attach(view2)
data2.attach(view2)
data2.attach(view1)
print “setting data 1 = 10”
data1.data = 10
print “setting data 2 = 15”
data2.data = 15
print “setting data 1 = 3”
data1.data = 3
print “setting data 2 = 5”
data2.data = 5
print “update data1’s view2 because view1 is be filtered”
data1.notify(modifier=view1)
print “detach hexviewer from data1 and data2.”
data1.detach(view2)
data2.detach(view2)
print “setting data 1 = 10”
data1.data = 10
print “setting data 2 = 15”
data2.data = 15