1.moshi.png
意图：
定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类。
适用性：
当一个类不知道它所必须创建的对象的类的时候。
当一个类希望由它的子类来指定它所创建的对象的时候。
当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。
案例一
#coding:utf8
'''
Factory Method
'''
class ChinaGetter:
"""A simple localizer a la gettext"""
def __init__(self):
self.trans = dict(dog=u"小狗", cat=u"小猫")
def get(self, msgid):
"""We'll punt if we don't have a translation"""
try:
return self.trans[msgid]
except KeyError:
return str(msgid)
class EnglishGetter:
"""Simply echoes the msg ids"""
def get(self, msgid):
return str(msgid)
def get_localizer(language="English"):
"""The factory method"""
languages = dict(English=EnglishGetter, China=ChinaGetter)
return languages[language]()
# Create our localizers
e, g = get_localizer("English"), get_localizer("China")
# Localize some text
for msgid in "dog parrot cat bear".split():
print(e.get(msgid), g.get(msgid))
案例二
1.创建一个工厂方法模式的包
在该包下分别创建product.py（要生产 产品类都在这里） 和factory.py（生产方法在这里）文件
①product.py文件
class Role:
def run(self):
pass
def fight(self):
pass
def die(self):
pass
class Monster(Role):
def run(self):
print('巫师跑')
def fight(self):
print("巫师战斗")
def die(self):
print("巫师死了")
class Enemy(Role):
def run(self):
print("小兵跑")
def fight(self):
print("小兵战斗")
def die(self):
print("小兵死了")
class Solder(Role):
def run(self):
print("战士跑")
def fight(self):
print("战士战斗")
def die(self):
print("战士战死")
②factory.py文件
from . import product
class Factory:
pass
class ConFactory(Factory):
def create_obj(self,name):
if name=='Monster':
return product.Monster()
elif name=='Enemy':
return product.Enemy()
elif name=='Solder':
return product.Solder()
else:
pass
在执行的py文件中调用，用来实例化指定的类
from patterns.factory_pattern.factory_package.factory import *
factory=ConFactory()
monster=factory.create_obj('Monster')
monster.run()
solder=factory.create_obj('Solder')
solder.fight()
enemy=factory.create_obj('Enemy')
enemy.die()
'''
运行结果:
巫师跑
战士战斗
小兵死了
'''
由此可见，工厂方法是定义了用于创建对象的接口，让子类决定实例化哪一个类。这个模式用到了里氏替换原则：所有引用基类的地方，必须能透明的使用其子类的对象。
