github地址:
题目
用程序模拟以下不同情况：
- 男人成功时，背后多半有一个伟大的女人；
- 女人成功时，背后多半有一个失败的男人；
- 男人失败时，闷头喝酒，谁也不用劝；
- 女人失败时，眼泪汪汪，谁也劝不了；
- 男人恋爱时，凡事不懂也要装逼；
- 女人恋爱时，遇事懂也装作不懂；
基础版本
from abc import ABCMeta,abstractmethodclass Person(): __metaclass__ = ABCMeta def __init__(self): self.action = None @abstractmethod def get_conclusion(self): pass class Man(Person): def get_conclusion(self): if self.action == "成功": print("男人成功时，背后多半有一个伟大的女人") elif self.action == "失败": print("男人失败时，闷头喝酒，谁也不用劝") elif self.action == "恋爱": print("男人恋爱时，凡事不懂也要装逼") class Woman(Person): def get_conclusion(self): if self.action == "成功": print("女人成功时，背后多半有一个失败的男人") elif self.action == "失败": print("女人失败时，眼泪汪汪，谁也劝不了") elif self.action == "恋爱": print("女人恋爱时，遇事懂也装作不懂")def main(): persons = [] man1 = Man() man1.action = "成功" persons.append(man1) woman1 = Woman() woman1.action = "成功" persons.append(woman1) man2 = Man() man2.action = "失败" persons.append(man2) woman2 = Woman() woman2.action = "失败" persons.append(woman2) man3 = Man() man3.action = "恋爱" persons.append(man3) woman3 = Woman() woman3.action = "恋爱" persons.append(woman3) for p in persons: p.get_conclusion() main() 男人成功时，背后多半有一个伟大的女人女人成功时，背后多半有一个失败的男人男人失败时，闷头喝酒，谁也不用劝女人失败时，眼泪汪汪，谁也劝不了男人恋爱时，凡事不懂也要装逼女人恋爱时，遇事懂也装作不懂
点评
上述代码算是初步的面向对象编程，但是在“Man”和“Woman”中那些“if-else”判断很复杂，如果再增加“结婚”状态，那需要增加分支判断。
这里我们可以使用访问者模式。
访问者模式
访问者模式，表示一个作用于某对象结构中各元素的操作。它使你可以在不改变各元素的类的前提下，定义作用于这些元素的新操作。[DP]
访问者模式的基本代码如下：
from abc import ABCMeta, abstractmethodclass Visitor(): """ Visitor类，为该对象结构中ConcretElement的每一个类声明一个Visit操作。 """ __metaclass__ = ABCMeta @abstractmethod def visit_concret_element_a(self, concret_element_a): pass @abstractmethod def visit_concret_element_b(self, concret_element_b): pass class ConcretVisitor1(Visitor): """ ConcretVisitor类，具体访问者，实现每个由Visitor声明的操作。每个操作实现算法的一部分， 而该算法片段乃是对应于结构中对象的类。 """ def visit_concret_element_a(self, concret_element_a): print("Visitor1 visit element A") def visit_concret_element_b(self, concret_element_b): print("Visitor1 visit element B") class ConcretVisitor2(Visitor): """ 同上 """ def visit_concret_element_a(self, concret_element_a): print("Visitor2 visit element A") def visit_concret_element_b(self, concret_element_b): print("Visitor2 visit element B") class Element(): """ Element类，定义一个Accept操作，它以一个访问者为参数 """ __metaclass__ = ABCMeta @abstractmethod def accept(self, visitor): pass class ConcretElementA(Element): """ 具体元素类，实现Accept操作 """ def accept(self, visitor): visitor.visit_concret_element_a(self) def other_functions_a(self): pass class ConcretElementB(Element): """ 具体元素类，实现Accept操作 """ def accept(self, visitor): visitor.visit_concret_element_b(self) def other_functions_b(self): pass class ObjectStructure(): """ ObjectStructure类，能枚举他的元素，可以提供一个高层的接口以允许访问者访问它的元素。 """ def __init__(self): self.elements = [] def accept(self, visitor): for element in self.elements: element.accept(visitor) def main(): o = ObjectStructure() o.elements.append(ConcretElementA()) o.elements.append(ConcretElementB()) v1 = ConcretVisitor1() v2 = ConcretVisitor2() o.accept(v1) o.accept(v2) main() Visitor1 visit element AVisitor1 visit element BVisitor2 visit element AVisitor2 visit element B
改进版本——访问者模式
from abc import ABCMeta, abstractmethodclass Action(): """ 状态抽象类，Visitor类，为该对象结构中ConcretElement的每一个类声明一个Visit操作。 """ __metaclass__ = ABCMeta @abstractmethod def get_man_conclusion(self, man): pass @abstractmethod def get_woman_conclusion(self, woman): pass class Success(Action): """ 成功状态类，ConcretVisitor类，具体访问者，实现每个由Visitor声明的操作。每个操作实现算法的一部分， 而该算法片段乃是对应于结构中对象的类。 """ def get_man_conclusion(self, man): print("男人成功时，背后多半有一个伟大的女人") def get_woman_conclusion(self, woman): print("女人成功时，背后多半有一个失败的男人") class Failing(Action): """ 失败状态类，ConcretVisitor类，具体访问者，实现每个由Visitor声明的操作。每个操作实现算法的一部分， 而该算法片段乃是对应于结构中对象的类。 """ def get_man_conclusion(self, man): print("男人失败时，闷头喝酒，谁也不用劝") def get_woman_conclusion(self, woman): print("女人失败时，眼泪汪汪，谁也劝不了") class Amativeness(Action): """ 恋爱状态类，ConcretVisitor类，具体访问者，实现每个由Visitor声明的操作。每个操作实现算法的一部分， 而该算法片段乃是对应于结构中对象的类。 """ def get_man_conclusion(self, man): print("男人恋爱时，凡事不懂也要装逼") def get_woman_conclusion(self, woman): print("女人恋爱时，遇事懂也装作不懂") class Person(): """ 人抽象类，Element类，定义一个Accept操作，它以一个访问者为参数 """ __metaclass__ = ABCMeta @abstractmethod def accept(self, visitor): pass class Man(Person): """ 男人类，具体元素类，实现Accept操作 """ def accept(self, visitor): """ 双分派技术： 第一次分派：首先在客户端程序中将具体状态作为参数传递给“男人”类完成一次分派； 第二次分派：然后“男人”类调用作为参数的“具体状态”中的方法“男人反应”，同事将自己(self)作为参数传递进去； """ visitor.get_man_conclusion(self) def other_functions_a(self): pass class Woman(Person): """ 女人类，具体元素类，实现Accept操作 """ def accept(self, visitor): visitor.get_woman_conclusion(self) def other_functions_b(self): pass class ObjectStructure(): """ ObjectStructure类，能枚举他的元素，可以提供一个高层的接口以允许访问者访问它的元素。 """ def __init__(self): self.elements = [] def accept(self, visitor): for element in self.elements: element.accept(visitor) def main(): o = ObjectStructure() o.elements.append(Man()) o.elements.append(Woman()) v1 = Success() v2 = Failing() v3 = Amativeness() o.accept(v1) print("-"*10) o.accept(v2) print("-"*10) o.accept(v3) main()print()print("由于使用了双分派技术，当新增`结婚`状态时，只需要新增一个状态子类，然后修改客户端即可。")print()class Marriage(Action): def get_man_conclusion(self, man): print("男人结婚时，有妻徒刑遥无期") def get_woman_conclusion(self, woman): print("女人结婚时，婚姻保险保平安") def main(): o = ObjectStructure() o.elements.append(Man()) o.elements.append(Woman()) v1 = Success() v2 = Failing() v3 = Amativeness() v4 = Marriage() o.accept(v1) print("-"*10) o.accept(v2) print("-"*10) o.accept(v3) print("-"*10) o.accept(v4) main() 男人成功时，背后多半有一个伟大的女人女人成功时，背后多半有一个失败的男人----------男人失败时，闷头喝酒，谁也不用劝女人失败时，眼泪汪汪，谁也劝不了----------男人恋爱时，凡事不懂也要装逼女人恋爱时，遇事懂也装作不懂由于使用了双分派技术，当新增`结婚`状态时，只需要新增一个状态子类，然后修改客户端即可。男人成功时，背后多半有一个伟大的女人女人成功时，背后多半有一个失败的男人----------男人失败时，闷头喝酒，谁也不用劝女人失败时，眼泪汪汪，谁也劝不了----------男人恋爱时，凡事不懂也要装逼女人恋爱时，遇事懂也装作不懂----------男人结婚时，有妻徒刑遥无期女人结婚时，婚姻保险保平安
点评
访问者模式适用于数据结构相对稳定的系统，它把数据结构和作用于数据结构上的操作之间的耦合解脱开，使得操作结合可以相对自由地演化。
访问这模式的目的是要把处理从数据结构分离出来。很多系统可以按照算法和数据结构分开，如果这样的系统有比较稳定的数据结构，又有易于变化的算法的话，那就比较适合使用访问者模式，因为访问者模式使得算法操作的增加变得容易。反之，如果系统的数据结构对象易于变化，经常要有新的数据对象增加进来，就不适合使用访问者模式。
访问者模式的优点就是增加新的操作很容易，因为增加新的操作就意味着增加一个新的访问者。访问者模式将有关的行为集中到一个访问者对象中。
访问者模式的缺点其实就是增加新的数据结构变得困难了。
GoF四人中的一个作者说过，大多数时候并不需要访问者模式，但当一旦需要访问者模式时，那就是真的需要它了。因为我们很难找到数据结构不变化的情况，所以用访问者模式的机会也就不太多。