1. 定義

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

demo地址，歡迎star

2. 結(jié)構(gòu)

Factory：工廠角色，負(fù)責(zé)實(shí)現(xiàn)創(chuàng)建所有實(shí)例的內(nèi)部邏輯；
Product：抽象產(chǎn)品角色，是所創(chuàng)建的所有對象的父類，負(fù)責(zé)描述所有實(shí)例所共有的公共接口；
ConcreteProduct：具體產(chǎn)品角色，是創(chuàng)建目標(biāo)，所有創(chuàng)建的對象都充當(dāng)這個角色的某個具體類的實(shí)例。

3. 代碼

UML圖示：

簡單工廠模式.png

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

CaculateDelegate 協(xié)議類

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

加、減、乘、除類

• 注 只列舉加法實(shí)現(xiàn)，其它類似

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

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

工廠類

//工廠類，統(tǒng)一返回對象，如果要添加新的對象，新建類，并添加至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

外部調(diào)用類

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協(xié)議

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"
    }
}

實(shí)現(xiàn)

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

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

優(yōu)缺點(diǎn)

• 優(yōu)點(diǎn)：客戶端不需要修改代碼。
• 缺點(diǎn)：當(dāng)需要增加新的運(yùn)算類的時候，不僅需新加運(yùn)算類，還要修改工廠類，違反了開閉原則。

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

demo地址，歡迎star