创建型模式-工厂方法

使用场景：继承，创建各种子类对象，一种继承关系

意义：

隐藏了选择子类、创建子类对象的过程，统一创建接口

原理描述：

这里强调一个管理类(通常用基类)、一个方法、返回不同子类对象。
当然如果有复杂的层级，只需要重复这个过程。

工厂模式原理图.png

具体使用：

1、一个常用、错误示范。

创建一个FactoryMethod的OS X命令行工程，创建一个RentalCar.swift文件

//协议
protocol RentalCar{ 
    var name:String{get}
    var passengers:Int{get}
    var pricePerDay:Float{get}
}

//协议继承
class Compact: RentalCar {
    var name = "VM Golf"
    var passengers = 3
    var pricePerDay: Float = 20
}

class Sports:RentalCar{

    var name = "Porsche Boxter"
    var passengers: Int = 1
    var pricePerDay: Float = 100
}

class SUV: RentalCar {
    var name = "Cadillac Escalade"
    var passengers: Int = 8
    var pricePerDay: Float = 75
}

再创建一个CarSelector.swift，一个调用类

class CarSelector{

    class func selectCar(passengers:Int) -> String?{
    var car:RentalCar?
    switch passengers {
    case 0...1:
        car = Sports()
    case 2...3:
        car = Compact()
    case 4...8:
        car = SUV()
    default:
        car = nil
    }
    return car?.name
    }
}

最后在main.swift中使用

let passengers = [1,3,5]

for p in passengers{

    print("\(p) pasengers:\(CarSelector.selectCar(passengers: p)!)")
}

使用的时候好像没有什么问题，新增一个类型的时候，看看需要改变哪些地方。

在RentalCar.swift新增一个类型Minivan

... 
 class SUV: RentalCar {
    var name = "Cadillac Escalade"
    var passengers: Int = 8
    var pricePerDay: Float = 75
}
//新增类型
class Mininvan: RentalCar{

    var name = "Chevrolet Evpress"
    var passengers = 14
    var pricePerDay: Float = 40
}

新增类型后，CarSelector.swift也需要更改:

class CarSelector{

    class func selectCar(passengers:Int) -> String?{
    var car:RentalCar?
    switch passengers {
    case 0...1:
        car = Sports()
    case 2...3:
        car = Compact()
    case 4...8:
        car = SUV()
   //新增逻辑
    case 9...14:
        car = Mininvan()
    default:
        car = nil
    }
    return car?.name
    }
}

1.1、问题：CarSelector需要知道所有子类类型，一旦新增子类，就需要更新逻辑。

新增一个调用类PriceCalculator.swift，还会有哪些问题？

class PriceCalculator{

    class func calculatorPrice(passengers:Int,days:Int) -> Float?{
    var car:RentalCar?
    switch passengers {
    case 0...1:
        car = Sports()
    case 2...3:
        car = Compact()
    case 4...8:
        car = SUV()
   //新增逻辑
    case 9...14:
        car = Mininvan()
    default:
        car = nil
    }
    return car == nil ? nil : car!. pricePerDay  * Float(days)
    }
}

1.2、问题：新增调用类，会重写一遍选择逻辑。思考一下，这段选择逻辑是可以隐藏起来的，调用类根本不需要关心这些，它只需要一个子类对象就可以了。

2、解决办法：封装选择逻辑，提供调用类一个获取对象的方法即可。

2.1、全局方法：

在RentalCar.swift中创建一个全局方法封装选择逻辑:

  func creatRentalCar(passengers:Int) -> RentalCar?{
    
    var car:RentalCar?
    
    switch passengers {
    case 0...1:
        car = Sports()
    case 2...3:
        car = Compact()
    case 4...8:
        car = SUV()
    case 9...14:
        car = Mininvan()
    default:
        car = nil
    }
    return car
}

protocol RentalCar{
    
    var name:String{get}
    var passengers:Int{get}
    var pricePerDay:Float{get}
}
...

CarSelector.swift使用起来就是这样的

  class func selectCar(passengers:Int) -> String?{
        
        return creatRentalCar(passengers: passengers)?.name
    }

PriceCalculator.swift

 class func calculatePrice(passengers:Int,days:Int) -> Float?{
        
        let  car = creatRentalCar(passengers: passengers)
        return car == nil ? nil : car!.pricePerDay * Float(days)
    }

选择逻辑完全隐藏起来，新增类、删除类，调用类根本不用变动。

2.2、使用基类

改造RentalCar.swift，使用基类替换协议，适当减少子类，为后续改变做准备。

class RentalCar{
    private var nameBV :String
    private var passengersBV:Int
    private var pricePerDayBV:Float
    
    private init(name:String,passengers:Int,price:Float) {
        self.nameBV = name
        self.passengersBV = passengers
        self.pricePerDayBV = price
    }
    
    final var name:String{
        get{ return nameBV }
    }
    
    final var passengers:Int{
        get { return passengersBV}
    }
    
    final var pricePerDay:Float{
        get { return pricePerDayBV }
    }
    class func creatRentalCar(passengers:Int) -> RentalCar?{
        
        var carI:RentalCar?
        
        switch passengers {
        case 0...3:
            car = Compact()
        case 4...8:
            car = SUV()
        default:
            car = nil
        }
        return car
    }
 
    class Compact:RentalCar{
        
        fileprivate init(){
            self.init(name: "VM Golf", passengers: 3, price: 20)
        }     
   }
     
    class SUV:RentalCar{
        
        fileprivate init(){
            super.init(name: "Cadillac Escalade", passengers: 8, price: 75)
        }
    }
}

使用基类时，为了达到协议的效果，使用final关键字修饰属性，避免属性被修改。还定义了一个私有构造方法，需要传递参数。

CarSelector.swift使用是这样的：

class func selectCar(passengers:Int) -> String?{
        
        return RentalCar.creatRentalCar(passengers: passengers)?.name
    }

PriceCalculator.swift：

 class func calculatePrice(passengers:Int,days:Int) -> Float?{
        
        let  car = RentalCar.creatRentalCar(passengers: passengers)
        return car == nil ? nil : car!.pricePerDay * Float(days)
    }

以下可选，对理解工厂模式影响不大，只是应用得更复杂，如果只是简单运用，到这里就可以了。

如果你能看懂我画的原理图，那么似乎还有一种稍微复杂的场景，子类里面还有子类实现。

3、子类里还有子类，可以把选择逻辑放到更深，如原理图。

RentalCar.swift新增一个继承Compact的子类SmallCompact

class RentalCar{
    private var nameBV :String
    private var passengersBV:Int
    private var pricePerDayBV:Float
    
    private init(name:String,passengers:Int,price:Float) {
        self.nameBV = name
        self.passengersBV = passengers
        self.pricePerDayBV = price
    }
    
    final var name:String{
        get{ return nameBV }
    }
    
    final var passengers:Int{
        get { return passengersBV}
    }
    
    final var pricePerDay:Float{
        get { return pricePerDayBV }
    }
    class func creatRentalCar(passengers:Int) -> RentalCar?{
        
        //元类型，RentalCar的任意类型，包括本身类型、还有子类类型
        var carImpl:RentalCar.Type?
        
        switch passengers {
        case 0...3:
            carImpl = Compact.self
        case 4...8:
            carImpl = SUV.self
        default:
            carImpl = nil
        }
        return carImpl?.creatRentalCar(passengers: passengers)
    }
    
    class Compact:RentalCar{
        
        fileprivate convenience init(){
            self.init(name: "VM Golf", passengers: 3, price: 20)
        }
        
        fileprivate override init(name:String,passengers:Int,price:Float){
            super.init(name: name, passengers: passengers, price: price)
        }
        //override重写父类方法，子类的选择逻辑
        override class func creatRentalCar(passengers:Int) -> RentalCar?{
            if passengers < 2 {
                return Compact()
            }else{
                return SmallCompact()
            }
        }
        
    class SmallCompact: Compact {
        fileprivate init(){
            super.init(name: "Ford Fiesta", passengers: 3, price: 15)
        }
    }
    
    class SUV:RentalCar{
        
        fileprivate init(){
            super.init(name: "Cadillac Escalade", passengers: 8, price: 75)
        }
        
        override class func creatRentalCar(passengers:Int) -> RentalCar?{
            return SUV()
        }
    }
}

里面使用到.Type，个人理解就是RentalCar的任意类型，包括本身类型、还有子类类型。.self就是具体的类型，这里就是指每个子类。如果你要了解详情，可以看看这个、还有王巍 (@ONEVCAT)的TIP。

3.1、还可以加入单例模式

其实用不用单例都无关紧要，因为调用类根本不关心细节。

class RentalCar{
    private var nameBV :String
    private var passengersBV:Int
    private var pricePerDayBV:Float
    
    private init(name:String,passengers:Int,price:Float) {
        self.nameBV = name
        self.passengersBV = passengers
        self.pricePerDayBV = price
    }
    
    final var name:String{
        get{ return nameBV }
    }
    
    final var passengers:Int{
        get { return passengersBV}
    }
    
    final var pricePerDay:Float{
        get { return pricePerDayBV }
    }
    class func creatRentalCar(passengers:Int) -> RentalCar?{
        
        //元类型，RentalCar的任意类型，包括本身类型、还有子类类型
        var carImpl:RentalCar.Type?
        
        switch passengers {
        case 0...3:
            carImpl = Compact.self
        case 4...8:
            carImpl = SUV.self
        default:
            carImpl = nil
        }
        return carImpl?.creatRentalCar(passengers: passengers)
    }
    
    class Compact:RentalCar{
        
        fileprivate convenience init(){
            self.init(name: "VM Golf", passengers: 3, price: 20)
        }
        
        fileprivate override init(name:String,passengers:Int,price:Float){
            super.init(name: name, passengers: passengers, price: price)
        }
        //override重写父类方法
        override class func creatRentalCar(passengers:Int) -> RentalCar?{
            if passengers < 2 {
                return shareInstance
            }else{
                return SmallCompact.shareInstance
            }
        }
        
        //单例
        class var shareInstance:RentalCar{
            
            get{
                struct SingletonWrapper{
                    static let singleton = Compact()
                }
                return SingletonWrapper.singleton
            }
        }
    }
    
    class SmallCompact: Compact {
        fileprivate init(){
            super.init(name: "Ford Fiesta", passengers: 3, price: 15)
        }
        
        override class var shareInstance:Compact{
            get{
                struct SingletonWrapper{
                    static let singleton = SmallCompact()
                }
                return SingletonWrapper.singleton
            }

        }
    }
    
    class SUV:RentalCar{
        
        fileprivate init(){
            super.init(name: "Cadillac Escalade", passengers: 8, price: 75)
        }
        
        override class func creatRentalCar(passengers:Int) -> RentalCar?{
            return SUV()
        }
    }
}

总结：

提供一个方法，封装好选择子类对象的逻辑，避免暴露细节。

Demo在这里，05工厂模式、SportsStoreDemo里面涉及的类Product.swift 、ProductDataStore

写在后面：

我写的关于设计模式内容，都是来自书《精通Swift设计模式》，如果有兴趣可以直接买来看看，不用看我的"歪曲理解"。我只是一个搬运工，记录过程，记录一点浅显的理解。

最后编辑于：2017.12.06 04:50:19

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 202,802评论 5赞 476
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 85,109评论 2赞 379
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 149,683评论 0赞 335
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,458评论 1赞 273
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,452评论 5赞 364
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,505评论 1赞 281
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 37,901评论 3赞 395
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,550评论 0赞 256
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 40,763评论 1赞 296
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,556评论 2赞 319
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,629评论 1赞 329
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,330评论 4赞 318
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 38,898评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,897评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,140评论 1赞 259
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 42,807评论 2赞 349
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,339评论 2赞 342