xml地图|网站地图|网站标签 [设为首页] [加入收藏]

python风格的抽象工厂模式,python风格工厂

时间:2020-01-04 21:40来源:计算机
python风格的抽象工厂模式,python风格工厂 抽象工厂模式: 提供一个接口,用户创建多个相关或依赖对象,而不需要指定具体类。 原则: 依赖抽象,不依赖具体类。 实例: 用不同原材

python风格的抽象工厂模式,python风格工厂

抽象工厂模式:

提供一个接口,用户创建多个相关或依赖对象,而不需要指定具体类。

原则:

依赖抽象,不依赖具体类。

实例:

用不同原材料制作不同口味的披萨,创建不同原材料的工厂,不同实体店做出口味不同的披萨。创建一个产品家族(Dough、Sauce、Cheese和Clam)的抽象类型(PizzaIngredientFactory),这个类型的子类(NYPizzaIngredientFactory和ChicagoPizzaIngredientFactory)定义了产品被产生的方法。

工厂模式和抽象工厂模式的区别:

工厂模式是在派生类中定义一个工厂的抽象接口,然后基类负责创建具体对象;抽象工厂模式是维护一个产品家族,由基类定义产品被生产的方法,客户根据派生类的接口进行开发。

代码:

#!/usr/bin/python
# -*- coding:utf-8 -*-
import sys
reload(sys)
sys.setdefaultencoding('utf-8')

'''
披萨
'''
class Pizza:
    name = ""
    dough = None
    sauce = None
    cheese = None
    clam = None

    def prepare(self):
        pass

    def bake(self):
        print "烘烤25分钟在350。".decode('utf-8')

    def cut(self):
        print "切割成对角线切片。".decode('utf-8')

    def box(self):
        print "放在官方的盒子中。".decode('utf-8')

    def get_name(self):
        return self.name

    def set_name(self, name):
        self.name = name

    def to_string(self):
        string = "%s:n" % self.name 
        string += "    面团: %sn" % self.dough.to_string() if self.dough else ""
        string += "    酱汁: %sn" % self.sauce.to_string() if self.sauce else ""
        string += "    奶酪: %sn" % self.cheese.to_string() if self.cheese else ""
        string += "    文蛤: %sn" % self.clam.to_string() if self.clam else ""
        return string

'''
什么类别的披萨
'''
class CheesePizza(Pizza):
    def __init__(self, ingredient_factory):
        self.ingredient_factory = ingredient_factory

    def prepare(self):
        print "准备: %s" % self.name
        self.dough = self.ingredient_factory.create_dough()
        self.sauce = self.ingredient_factory.create_sauce()
        self.cheese = self.ingredient_factory.create_cheese()


class ClamPizza(Pizza):
    def __init__(self, ingredient_factory):
        self.ingredient_factory = ingredient_factory

    def prepare(self):
        print "准备: %s" % self.name
        self.dough = self.ingredient_factory.create_dough()
        self.sauce = self.ingredient_factory.create_sauce()
        self.clam = self.ingredient_factory.create_clam()

'''
披萨店
'''
class PizzaStore:
    def order_pizza(self, pizza_type):
        self.pizza = self.create_pizza(pizza_type)
        self.pizza.prepare()
        self.pizza.bake()
        self.pizza.cut()
        self.pizza.box()
        return self.pizza

    def create_pizza(self, pizza_type):
        pass

'''
纽约披萨实体店1
'''
class NYPizzaStore(PizzaStore):
    def create_pizza(self, pizza_type):
        ingredient_factory = NYPizzaIngredientFactory()

        if pizza_type == "cheese":
            pizza = CheesePizza(ingredient_factory)
            pizza.set_name("纽约风格芝士披萨".decode('utf-8'))
        elif pizza_type == "clam":
            pizza = ClamPizza(ingredient_factory)
            pizza.set_name("纽约风格文蛤披萨".decode('utf-8'))
        else:
            pizza = None

        return pizza

'''
芝加哥披萨实体店2
'''
class ChicagoPizzaStore(PizzaStore):
     def create_pizza(self, pizza_type):
        ingredient_factory = ChicagoPizzaIngredientFactory()

        if pizza_type == "cheese":
            pizza = CheesePizza(ingredient_factory)
            pizza.set_name("芝加哥风格芝士披萨".decode('utf-8'))
        elif pizza_type == "clam":
            pizza = ClamPizza(ingredient_factory)
            pizza.set_name("芝加哥风格文蛤披萨".decode('utf-8'))
        else:
            pizza = None

        return pizza

'''
生产披萨的工厂
'''
class PizzaIngredientFactory:
    def create_dough(self):
        pass

    def create_sauce(self):
        pass

    def create_cheese(self):
        pass

    def create_clam(self):
        pass

'''
生产披萨的实体工厂1
'''
class NYPizzaIngredientFactory(PizzaIngredientFactory):
    def create_dough(self):
        return ThinDough()

    def create_sauce(self):
        return MarinaraSauce()

    def create_cheese(self):
        return FreshCheese()

    def create_clam(self):
        return FreshClam()

'''
生产披萨的实体工厂2
'''
class ChicagoPizzaIngredientFactory(PizzaIngredientFactory):
    def create_dough(self):
        return ThickDough()

    def create_sauce(self):
        return MushroomSauce()

    def create_cheese(self):
        return BlueCheese()

    def create_clam(self):
        return FrozenClam()


class Dough:
    def to_string(self):
        pass

class ThinDough(Dough):
    def to_string(self):
        return "薄的面团"

class ThickDough(Dough):
    def to_string(self):
        return "厚的生面团"

class Sauce:
    def to_string(self):
        pass

class MarinaraSauce(Sauce):
    def to_string(self):
        return "番茄酱"

class MushroomSauce(Sauce):
    def to_string(self):
        return "蘑菇酱"

class Cheese:
    def to_string(self):
        pass

class FreshCheese(Cheese):
    def to_string(self):
        return "新鲜的奶酪"

class BlueCheese(Cheese):
    def to_string(self):
        return "蓝纹奶酪"

class Clam:
    def to_string(self):
        pass

class FreshClam(Clam):
    def to_string(self):
        return "新鲜的文蛤"

class FrozenClam(Clam):
    def to_string(self):
        return "冷冻的文蛤"

if __name__ == "__main__":
 # 创建了两个披萨实体店
    ny_store = NYPizzaStore()
    chicago_store = ChicagoPizzaStore()

    # 在第一个披萨对象中订购了一个cheese风味的披萨
    pizza = ny_store.order_pizza("cheese")
    print pizza.to_string()
    print "迈克订购了一个 %s" % pizza.get_name()
    print 

    pizza = chicago_store.order_pizza("clam")
    print pizza.to_string()
    print "约翰订购了一个%s" % pizza.get_name()
    print

结果:

准备: 纽约风格芝士披萨
烘烤25分钟在350。
切割成对角线切片。
放在官方的盒子中。
纽约风格芝士披萨:
    面团: 薄的面团
    酱汁: 番茄酱
    奶酪: 新鲜的奶酪

迈克订购了一个 纽约风格芝士披萨

准备: 芝加哥风格文蛤披萨
烘烤25分钟在350。
切割成对角线切片。
放在官方的盒子中。
芝加哥风格文蛤披萨:
    面团: 厚的生面团
    酱汁: 蘑菇酱
    文蛤: 冷冻的文蛤

约翰订购了一个芝加哥风格文蛤披萨

 

工厂模式,简单工厂模式,抽象工厂模式三者有什不同

工厂模式的好处就在于将工厂和产品之间的耦合降低,将具体产品的构造过程放在了具体工厂类里面。在以后扩展产品的时候方便很多,只需要添加一个工厂类,一个产品类,就能方便的添加产品,而不需要修改原有的代码。而在简单工厂中,如果要增加一个产品,则需要修改工厂类,增加if/else分支,或者增加一个case分支,工厂模式符合软件开发中的OCP原则(open close principle),对扩展开放,对修改关闭。
抽象工厂模式:这个模式我总是感觉和builder模式非常相似。
工厂方法模式提供的是对一个产品的等级模式,,而抽象工厂方法提供的是对多个产品的等级模式,注意,这里的多个具体产品之间是相互耦合的,也就是说这里的抽象工厂提供的产品之间是存在某种联系的。
有人做如下的比较:
工厂方法模式:一个抽象产品类,可以派生出多个具体产品类。
一个抽象工厂类,可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。
抽象工厂模式:多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类,可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。
区别:工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个。
下面是一个形象的比喻:
无论是简单工厂模式、工厂模式还是抽象工厂模式,它们本质上都是将不变的部分提取出来,将可变的部分留作接口,以达到最大程度上的复用。拿一个生产水杯(cup)的工厂举例:起初,不用工厂模式,我必须在生产水杯之前知道水杯的材料和形状等水杯的所有特征才能生产,这就是我们的new Cup();这个Cup必须是具体的。厂主发现同一形状的被子,只是材料不同,如一个是玻璃(glass)的,一个是瓷(china)的,但是确要两条生产线,显然有资源浪费的嫌疑。现在厂主生产杯子时先不让生产线知道我要产的是玻璃的还是瓷的,而是让它在不知道具体材料的情况下先做它能做的,等到它把模具做好,只需要向其中填充玻璃原料或者瓷原料就可以造出同一形状的具体杯子了。但是很可惜,java并不能new一个抽象的Cup,所以就有了简单工厂模式。原来是Cup cup=new Cup;现在是SimpleCupFactory.createCup(String cupName),根据cup的名字生产Cup,而createCup返回的是一个实现了 Cup接口或抽象类的具体Cup。简单抽象工厂模式有一个问题,就是当我现在想生产一个同样形状的铁杯时,工厂里并没有定义相应的处理流程,只能更改createCup方法,这就不合理了。我现在只是想生产铁杯,你只要在最后的时候把玻璃原料换成铁的不就行了吗,干嘛还要更改整条生产线呢?于是就有了工厂模式。原来生产线在生产模具的时候还要考虑是为玻璃杯生产的模具还是为铁杯生产的模具,现在它不用管了。CupFactory.createCup()创建Cup.CupFactory是接口或抽象类。实现它的具体子类会创建符合Cup接口的具体Cup。那么现在厂主想要生产水壶(kettle),用工厂模式就不得不再造一条水壶生产线,能不能在水杯生产线同时生产水壶呢?这就是抽象工厂模式。  

抽象工厂模式: 提供一个接口,用户创建多个相关或依赖对象,而不需要指定具体类。 原则:...

工厂方法模式与抽象工厂模式的不同

工厂方法模式:
一个抽象产品类,可以派生出多个具体产品类。
一个抽象工厂类,可以派生出多个具体工厂类。
每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式:
多个抽象产品类,每个抽象产品类可以派生出多个具体产品类。
一个抽象工厂类,可以派生出多个具体工厂类。
每个具体工厂类可以创建多个具体产品类的实例。

区别:
工厂方法模式只有一个抽象产品类,而抽象工厂模式有多个。
工厂方法模式的具体工厂类只能创建一个具体产品类的实例,而抽象工厂模式可以创建多个。  

编辑:计算机 本文来源:python风格的抽象工厂模式,python风格工厂

关键词: