1. 定義

簡單工廠模式(Simple Factory Pattern)：又稱為靜態工廠方法(Static Factory Method)模式，它屬于類創建型模式。在簡單工廠模式中，可以根據參數的不同返回不同類的實例。簡單工廠模式專門定義一個類來負責創建其他類的實例，被創建的實例通常都具有共同的父類。

demo地址，歡迎star

2. 結構

Factory：工廠角色，負責實現創建所有實例的內部邏輯；
Product：抽象產品角色，是所創建的所有對象的父類，負責描述所有實例所共有的公共接口；
ConcreteProduct：具體產品角色，是創建目標，所有創建的對象都充當這個角色的某個具體類的實例。

3. 代碼

UML圖示：

簡單工廠模式.png

加(CaculateAdd)、減(CaculateMinus)、乘(CaculateMultiply)、除類全部遵守CaculateDelegate協議，實現計算方法

CaculateDelegate 協議類

//簡單加、減、乘、除代理
protocol CaculateDelegate {
    var numberA: Float { get set }
    var numberB: Float { get set }
    
    func caculate() -> Float
}

加、減、乘、除類

• 注 只列舉加法實現，其它類似

class CaculateAdd: NSObject, CaculateDelegate {
    var numberA: Float = 0.0
    var numberB: Float = 0.0

    func caculate() -> Float {
        return numberA + numberB
    }
}

工廠類

//工廠類，統一返回對象，如果要添加新的對象，新建類，并添加至case中
class Factory: NSObject {
    class func createOperator(operatorParameter: String) -> AnyObject {
        let operators = ["+", "-", "*", "/"];
        let type: CaculateType = CaculateType(rawValue: operators.index(of: operatorParameter) ?? 0) ?? CaculateType.Add

        switch type {
        case .Add:
            return CaculateAdd()
        case .Minus:
            return CaculateMinus()
        case .Multiply:
            return CaculateMultiply()
        case .Divide:
            return CaculateDivide()
        }
    }
}

4、HeadFirst 流程

簡單工廠模式.jpg

demo地址，歡迎star

外部調用類

class PizzaSotre {
    var simpleFactory: SimplePizzaFactory

    init(simpleFactory: SimplePizzaFactory) {
        self.simpleFactory = simpleFactory
    }

    func orderPizza(type: String) -> PizzaProtocol {
        let pizza = simpleFactory.createPizza(type: type)
        //pizza的其它操作
        pizza.prepare()
        pizza.bake()
        pizza.cut()
        pizza.box()
        return pizza
    }
}

工廠方法

class SimplePizzaFactory {
    func createPizza(type: String = "") -> PizzaProtocol {
        switch type {
        case "cheese":
            return CheesePizza()
        case "pepperoni":
            return PepperoniPizza()
        case "clam":
            return ClamPizza()
        default:
            return Pizza()
        }
    }
}

Pizza協議

protocol PizzaProtocol {
    var name: String { get set }
    var sauce: String { get set }
    var daugh: String { get set }
    func prepare()
    func bake()
    func cut()
    func box()
}

Pizza基類

class Pizza: PizzaProtocol {
    var name: String = "Unknow Pizza"
    var sauce: String = "Unknow Sauce"
    var daugh: String = "Unknow Daugh"
    var toppings: [String] = []

    func prepare() {
        print("Preparing + \(name)")
        print("Tossing dough...")
        print("Adding sauce...")
        print("Adding toppings...")
    }

    func bake() {
        print("Bake for 25 minutes for 350")
    }

    func cut() {
        print("Cutting the pizza into diagonal slice")
    }

    func box() {
        print("Place pizza in offical Pizzastore Box")
    }
}

具體Pizza

class CheesePizza: Pizza {
    override init() {
        super.init()
        name = "Cheese Pizza"
    }
}

實現

let simpleFactory = SimplePizzaFactory()
let pizzaStore = PizzaSotre(simpleFactory: simpleFactory)

print("---------------------預定第一個pizza---------------------")
let cheesePizza = pizzaStore.orderPizza(type: "cheese")
print("---------------------預定第二個pizza---------------------")
let clmaPizza = pizzaStore.orderPizza(type: "clam")

優缺點

• 優點：客戶端不需要修改代碼。
• 缺點：當需要增加新的運算類的時候，不僅需新加運算類，還要修改工廠類，違反了開閉原則。

對于計算器這樣的簡單的設計，如果不借助工廠模式， 那么就要我們自己對不同的運算做相應的處理。這樣一是不易維護，二是不是擴展。當然，工廠模式只是應對一些簡單的場景。工廠模式囊括了所有的情況，如果要增加其它的情況，就需要修改工廠類。

demo地址，歡迎star