使用场景：复制对象
意义：
1、初始化开销大对象，特别是树形结构的对象，主要指消耗内存和计算资源。
2、对模版产生依赖的对象，避免模版改动，其他各处也会变动。
复制概念
所谓复制，我理解的是，一定要生成对象，才能达到复制的目的。
而经常说的深复制和浅复制，不过是为了绕晕别人搞的文字游戏。在我看来只有两种，可复制和不可复制。
1、OC的Foundation类实现了继承自NSObject、遵守NSCopying协议，并且是可变的，比如NSMutableString、NSMutableArray等具有复制功能。那不可变的，如NSString、NSArray使用mutablecopy也具有复制功能，但复制得到的也是可变的。
2、OC自定义的类，也必须实现NSCopying协议才具有复制功能，但需要解决树形结构的复制，要完整复制，必须所有属性也都具有复制功能。
Swift的复制
1、值类型数据，自动具备复制功能。值类型是什么？使用结构体定义的数据。简单说结构体具有复制功能，Swift内置类型都是结构体，如字符串、布尔值、集合、枚举、元组和数值。具体使用的时候简单赋值即可，不用使用copy方法。
如下：
struct Appointment{
var name:String
var day:String
var place:String
func printDetail(label:String){
print("\(label) with \(name) on \(day) at \(place)")
}
}
var beerMeeting = Appointment(name:"Bob",day:"Mon",place:"Joe's Bar")
//直接赋值完成复制
var workMeeting = beerMeeting
workMeeting.name = "Alice"
workMeeting.day = "Fri"
workMeeting.place = "Conference Rm 2"
beerMeeting.printDetail(label: "Social")
workMeeting.printDetail(label: "Work")
//结果：
//Social with Bob on Mon at Joe's Bar
//Work with Alice on Fri at Conference Rm 2
2、引用类型，即类创建的对象。直接赋值没有复制功能，需要实现NSCopying协议才具有复制功能。这也是类和结构体的重要区别。
如下：
class Apponitment:NSObject,NSCopying{
var name:String
var day:String
var place:String
init(name:String,
day:String,
place:String) {
self.name = name
self.day = day
self.place = place
}
func printDetail(label:String) {
print("\(label) with \(name) on \(day) at \(place)")
}
//实现协议方法
func copy(with zone: NSZone? = nil) -> Any {
return Apponitment.init(name: self.name,
day: self.day,
place: self.place)
}
}
var beerMeeting = Apponitment(name:"Bob",day:"Mon",place:"Joe's Bar")
//使用copy复制，转换成Apponitment类型
var workMeeting = beerMeeting.copy() as! Apponitment
workMeeting.name = "Alice"
workMeeting.day = "Fri"
workMeeting.place = "Conference Rm 2"
beerMeeting.printDetail(label: "Social")
workMeeting.printDetail(label: "Work")
3、无论是OC还是Swift，做复制功能的时候，需要检查对象的所有属性是否都具有复制功能，特别是复杂的树形结构。
如2的例子里面，新增一个Location类，作为Appointment的属性值，虽然Appointment实现了NSCopying协议，但是Location没有实现，所以复制Location属性时是不成功的。所以完整的复制功能是，所有属性都要实现NSCopying协议。
如下：
class Location:NSObject,NSCopying{
var name:String
var address:String
init(name:String,
address:String) {
self.name = name
self.address = address
}
func copy(with zone: NSZone? = nil) -> Any {
return Location.init(name: self.name, address: self.address)
}
}
class Apponitment:NSObject,NSCopying{
var name:String
var day:String
var place:Location
init(name:String,
day:String,
place:Location) {
self.name = name
self.day = day
self.place = place
}
func printDetail(label:String) {
print("\(label) with \(name) on \(day) at \(place.name) + \(place.address)")
}
//实现协议方法,并且内部需要copy Location
func copy(with zone: NSZone? = nil) -> Any {
return Apponitment.init(name: self.name,
day: self.day,
place: self.place.copy() as! Location)
}
}
var beerMeeting = Apponitment(name:"Bob",day:"Mon",place:Location.init(name: "Joe's Bar", address: "123 Main St"))
//使用copy复制，转换类型
var workMeeting = beerMeeting.copy() as! Apponitment
workMeeting.name = "Alice"
workMeeting.day = "Fri"
workMeeting.place.name = "Conference Rm 2"
workMeeting.place.address = "Company HQ"
//结果发现place也变化了，实现了深复制
beerMeeting.printDetail(label: "Social")
workMeeting.printDetail(label: "Work")
4、为了避免对模版创建的依赖，做到分离对象的创建和使用，也常使用到原型模式，也适用于OC。
有一种情况，我们需要产生新的对象，只是改变其中某个属性，通常会初始化去生成新的对象。但是如果这种初始化操作放在其他类里面，就有可能产生强耦合，当初始化方法改变的时候，使用到它的类都要改变。
如下：
class Message{
var to:String
var subject:String
init(to:String,
subject:String) {
self.to = to
self.subject = subject
}
}
class MessageLogger{
var messages:[Message] = []
//1、第一次变动，为了让数组里对象都不一样，采用初始化方法
//但这样做有一个缺点，就是会随着初始化方法改变而改变
//
func logMessage(msg:Message){
messages.append(Message.init(to: msg.to, subject: msg.subject))
}
func processMessage(callback:(Message) -> Void){
for msg in messages{
callback(msg)
}
}
}
var logger = MessageLogger()
var message = Message.init(to: "Joe", subject: "Hello")
logger.logMessage(msg: message)
message.to = "Bob"
message.subject = "Free for dinner?"
logger.logMessage(msg: message)
logger.processMessage { msg -> Void in
print("Message - To:\(msg.to) Subject:\(msg.subject)")
}
var data = [Message]()
var copiedData = NSMutableArray(array:data,copyItems:true)
表面上看好像问题不是很大，但是当Message初始化方法改变、有新的Message子类的时候，又会改变MessageLogger。一劳永逸的办法就是使用复制，原型模式
如下:
class Message :NSObject,NSCopying{
var to:String
var subject:String
init(to:String,
subject:String) {
self.to = to
self.subject = subject
}
//实现copy协议
func copy(with zone: NSZone? = nil) -> Any {
return Message.init(to: self.to, subject: self.subject)
}
}
class MessageLogger{
var messages:[Message] = []
//直接copy对象即可,以后就不用改变了。
func logMessage(msg:Message){
messages.append(msg.copy() as! Message)
}
func processMessage(callback:(Message) -> Void){
for msg in messages{
callback(msg)
}
}
}
var logger = MessageLogger()
var message = Message.init(to: "Joe", subject: "Hello")
logger.logMessage(msg: message)
message.to = "Bob"
message.subject = "Free for dinner?"
logger.logMessage(msg: message)
logger.processMessage { msg -> Void in
print("Message - To:\(msg.to) Subject:\(msg.subject)")
}
5、Swift支持通过属性修饰符来改变属性行为，例如可以用@NSCopying可以为继承NSObject并实现了NSCopying协议的对象，合成调用copy的setter方法。
class LogItem{
var from:String?
@NSCopying var data:NSArray?
}
var dataArray = NSMutableArray(array:[1,2,3])
var logItem = LogItem()
logItem.from = "Alice"
logItem.data = dataArray
dataArray[1] = 10
print("value: \(logItem.data?[1])")
但@NSCopying也有局限性，对象初始化时并不会被复制，这也是为什么data设置为可选类型。另外@NSCopying只会执行copy方法，即使是可变的集合执行完copy，也会变成不可变。
总结
1、当需要创建多个同一类型的对象的时候，都可以思考一下是否可以使用原型模式
2、在实现copy协议方法的时候，我们往往都返回一个初始化方法，所以我觉得如果初始化方法开销很大，原型模式并不能解决。原型模式解决的是，创建树形结构的对象开销过大，例如我们只需要修改树形结构最末的属性，就没必要从头开始创建。
里面的例子
写在后面：
我写的关于设计模式内容，都是来自书《精通Swift设计模式》，如果有兴趣可以直接买来看看，不用看我的"歪曲理解"。我只是一个搬运工，记录过程，记录一点浅显的理解。