- 注意！！！！ 如果你是技术大牛、技术大咖，请略过这篇文章避免耽搁您的时间，这篇文章属于入门级别。😀
1、原型模式的概述：用原型实例对象指定创建对象种类，并且通过拷贝这些原型创建新的对象（根据原始对象，Copy一个对象---Copy：浅拷贝和深度拷贝）
2、原型模式的使用场景：
- 当我们编写组件需要创建新的对象，但又不需要依赖初始化操作（就像swift中的UIView组件）不依赖于构造器-->构造方法
- 初始化的过程需要消耗非常大的资源（数据资源：构造方法需要很多数据参数、硬件资源...）
原型模式的一些角色：克隆接口或者说协议（protocoltype抽象，相当于iOS中的NSCopying）、具体的实现类(concreteType)、客户端(client),用一个简单的实例（浅拷贝）理解一下
//浅拷贝协议
protocol ShallowCopyProtocal {
func clone() -> AnyObject?
}
//具体的实现类
class UserCopyModel: ShallowCopyProtocal {
var name:String?
var sex:String?
init(name:String,sex:String) {
self.name = name
self.sex = sex
}
func clone() -> AnyObject? {
return UserCopyModel(name:self.name!, sex:self.sex!)
}
}
//===========浅度拷贝测试===========
//原型对象
let user = UserCopyModel(name: "YSL", sex: "男")
//克隆对象
let copyUser:UserCopyModel = user.clone() as! UserCopyModel
//修改克隆对象的值，看看原型对象会不会改变
copyUser.name = "Andy"
copyUser.sex = "man"
print("原型对象:name = \(user.name!) sex= \(user.sex!)")
print("克隆对象:name = \(copyUser.name!) sex= \(copyUser.sex!)")
//打印结果如下
原型对象:name = YSL sex= 男
克隆对象:name = Andy sex= man
- 上面的实例拷贝的是值类型（直接拷贝数据），并不是引用类型，所以不会改变原型对象值
再来看一下原型设计：数组的浅拷贝
protocol ShallowCopyProtocal {
func clone() -> AnyObject?
}
class TeacherModel {
var name:String?
init(name:String) {
self.name = name
}
}
class StudentCopyModel: ShallowCopyProtocal {
var name:String?
var teachers:Array<TeacherModel>?
init(name:String, teachers:Array<TeacherModel>) {
self.name = name
self.teachers = teachers
}
func clone() -> AnyObject? {
return StudentCopyModel(name: self.name!, teachers: self.teachers!)
}
}
//数组的浅拷贝测试
let array = [TeacherModel(name:"Jack"),TeacherModel(name:"Rose")]
let student = StudentCopyModel(name: "Mimi", teachers: array)
let copyStudent: StudentCopyModel = student.clone() as! StudentCopyModel
copyStudent.name = "DaChanglian"
copyStudent.teachers?[0].name = "Lisa"
print("原型对象:name = \(student.name!) teachers = \(String(describing: student.teachers![0].name))")
print("克隆对象:name = \(copyStudent.name!) teachers = \(String(describing: copyStudent.teachers![0].name))")
//输出结果
原型对象:name = Mimi teachers = Optional("Lisa")
克隆对象:name = DaChanglian teachers = Optional("Lisa")
- 看到以上结果，应该明白，数组是重新创建了，但是数组中保存的对象没有重新创建（也就是说数组保存的是对象的引用类型，那么拷贝的时候拷贝的是数组的值，数组的值就是TeacherModel对象的引用）。
- 这样对数组中的对象重新赋值，其实是改变了对象的值。如何证明数组保存的是对象的引用，直接打印数组就可以证明了。打印结果如下：
print("原型对象：teachers = \(student.teachers!)\n克隆对象：teachers = \(copyStudent.teachers!)")
原型对象：teachers = [ArchitectGenerics.TeacherModel, ArchitectGenerics.TeacherModel]
克隆对象：teachers = [ArchitectGenerics.TeacherModel, ArchitectGenerics.TeacherModel]
如果遇到以上的问题，我们如何解决这样的问题呢？答案就是原型模式-->深度拷贝。再看一个例子,解决一下这个问题😀
//深度拷贝协议接口
protocol DeepCopyProtocal {
func deepClone() -> AnyObject?
}
//深度拷贝测试的具体类 老师类
class TeacherModel2: DeepCopyProtocal {
var name:String?
init(name:String) {
self.name = name
}
func deepClone() -> AnyObject? {
return TeacherModel2(name: self.name!)
}
}
//深度拷贝的测试类 学生类
class DeepCopyStudentModel: DeepCopyProtocal {
var name:String?
var teachers:Array<TeacherModel2>?
init(name:String, teachers:Array<TeacherModel2>) {
self.name = name
self.teachers = teachers
}
func deepClone() -> AnyObject? {
var newArray = Array<TeacherModel2>()
for teacher in self.teachers! {
newArray.append(teacher.deepClone() as! TeacherModel2)
}
return DeepCopyStudentModel(name: self.name!, teachers: newArray)
}
}
// ============ 深度拷贝测试===========
let array = [TeacherModel2(name:"Jack"),TeacherModel2(name:"Rose")]
let student = DeepCopyStudentModel(name: "Mimi", teachers: array)
let copyStudent: DeepCopyStudentModel = student.deepClone() as! DeepCopyStudentModel
copyStudent.name = "DaChangLian"
copyStudent.teachers?[0].name = "Lisa"
print("原型对象:name = \(student.name!) teachers = \(String(describing: student.teachers![0].name))")
print("克隆对象:name = \(copyStudent.name!) teachers = \(String(describing: copyStudent.teachers![0].name))")
//=========打印结果================
原型对象:name = Mimi teachers = Optional("Jack")
克隆对象:name = DaChangLian teachers = Optional("Lisa")
- 深度拷贝是重新拷贝对象(在调用deepCopy()方法的时候重新创建了新的对象)，引用对象的值改变，不影响原型对象
