设计模式学习 - 工厂模式

工厂模式：

定义了一个创建对象的接口，但由它的子类决定实例化哪一个对象。工厂方法将对象的实例化延迟到了子类。

 

模式组成：

• 一组使用者：父类定义一个创建对象的接口及其他通用接口，子类负责创建对象接口的具体实现（在案例中为 PizzaStore 及 NYPizzaStore）
• 一组产品类：（在案例中为 抽象Pizza类及其具体实现的子类）

 

注：

1. 　　每一个使用者的子类负责创建一个（组）相似对象。

 

UML 类图：

 

代码具体实现：

1、 对象的创建者： PizzaStore 类

// pizza Store 父类：包含了创建pizza（createPizza）这个抽象方法

class PizzaStore {

    // 包含了一个产品的抽象类 和 一个简单工厂

    var pizza:Pizza = Pizza()

    

    // 提供 pizza 方法

    func orderPizza(pizzatype: Pizzatype) {

        // 获取相应商店创建的 pizza 对象的引用

        self.pizza = createPizza(pizzatype)

        

        // 产品的行为

        pizza.prepare()

        pizza.bake()

        pizza.cut()

        pizza.box()

    }

    

    // 创建一个 负责创建对象的接口，但是它由实现子类具体实现

    func createPizza(pizzatype: Pizzatype) -> Pizza {

        return Pizza()

    }

}



// 纽约Pizza商店：负责创建纽约风味的Pizza

class NYPizzaStore: PizzaStore {

    // 具体实现 负责创建对象的接口

    override func createPizza(pizzatype: Pizzatype) -> Pizza {

        switch pizzatype {

        case Pizzatype.Cheese:

            pizza = NYCheesePizza()

        case Pizzatype.Clam:

            pizza = NYClamPizza()

        }

        

        return pizza

    }

}



// 芝加哥Pizza商店：负责创建芝加哥风味的Pizza

class ChicagoPizzaStore: PizzaStore {

    // 具体实现 负责创建对象的接口

    override func createPizza(pizzatype: Pizzatype) -> Pizza {

        switch pizzatype {

        case Pizzatype.Cheese:

            pizza = ChicagoCheesePizza()

        case Pizzatype.Clam:

            pizza = ChicagoClamPizza()

        }

        

        return pizza

    }

}

 

2、对象类：

// 对象的父类

class Pizza {

    var name:String  = ""

    var dough:String = ""

    var sauce:String = ""

    var toppings:[String] = []

    

    // 准备pizza 方法

    func prepare() {

        println("正在准备 \(name) ...")

        println("Tossing dough...")

        println("加入 \(sauce)...")

        for topping:String in toppings {

            println("   \(topping)")

        }

    }

    

    func box() {

        println("正在打包...\n")

    }

    

    func bake() {

        println("正在烘焙...")

    }

    

    func cut() {

        println("正在裁剪...")

    }

}



// 一个纽约风味的 Cheese Pizza； 它与 纽约风味的 Clem Pizza 同为一组

class NYCheesePizza: Pizza {

    override init() {

        super.init()

        self.name = "纽约风味的 Cheese Pizza"

        self.dough = "Thin Crust Dough"

        self.sauce = "草莓 酱汁"

        

        toppings.append("Grated Reggino Cheese")

    }

}



// 一个纽约风味的 Clam Pizza

class NYClamPizza: Pizza {

    override init() {

        super.init()

        self.name = "纽约风味的 NYClam Pizza"

        self.dough = "Low Crust Dough"

        self.sauce = "樱桃 酱汁"

        

        toppings.append("Grated Reggino Clam")

    }

}



// 一个芝加哥风味的 Cheese Pizza； 它与 芝加哥风味的 Clem Pizza 同为一组

class ChicagoCheesePizza: Pizza {

    override init() {

        super.init()

        self.name = "芝加哥风味的 Cheese Pizza"

        self.dough = "Thin Crust Dough"

        self.sauce = "芒果 酱汁"

        

        toppings.append("Grated Reggino Cheese")

    }

    

    // 子类也可以覆盖父类的方法

    override func cut() {

        println("正在裁剪：裁剪成方块状...")

    }

}



// 一个芝加哥风味的 Clam Pizza

class ChicagoClamPizza: Pizza {

    override init() {

        super.init()

        self.name = "芝加哥风味的 Clam Pizza"

        self.dough = "Low Crust Dough"

        self.sauce = "烤肉 酱汁"

        

        toppings.append("Grated Reggino Clam")

    }

    

    // 子类也可以覆盖父类的方法

    override func cut() {

        println("正在裁剪：裁剪成方块状...")

    }

}

 

3、测试代码：

// 先访问 纽约Pizza商店

var pizzaStore: PizzaStore = NYPizzaStore()

// 买一个纽约风味的CheesePizza

/* 

先调用了 NYPizzaStore 的 orderPizza 方法，再由 orderPizza 方法调用 createPizza 方法；

其中 orderPizza 方法是父类创建的，为子类所共有使用，orderPizza 并不需要知道这个 Pizza 到底是哪一个种类的，只需要知道这是一个 Pizza 能进行准备、裁剪等行为就足够了

而 createPizza 方法则是子类自己按照相应的情况具体实现去创建相应风味的 Pizza；

*/

pizzaStore.orderPizza(Pizzatype.Cheese)



// 再访问 芝加哥Pizza商店，买一个芝加哥风味的ClamPizza

pizzaStore = ChicagoPizzaStore()

pizzaStore.orderPizza(Pizzatype.Clam)

 

4、测试结果