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