设计模式之原型模式

  • 注意!!!! 如果你是技术大牛、技术大咖,请略过这篇文章避免耽搁您的时间,这篇文章属于入门级别。😀

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()方法的时候重新创建了新的对象),引用对象的值改变,不影响原型对象
如果有不同的见解 --> 留言区 ---> 请多多指教。🙏 👍 😀

推荐阅读更多精彩内容

  • 原型模式 1.定义: 用原型实例指定创建对象的种类,并通过copy这些原型创建新的对象。 2.使用场景: 类初始化...
    TangBuzhi阅读 172评论 0 0
  • 前言 在 Java 中,我们可以使用 new 关键字指定类名来生成类的实例。但是,有的时候,我们也会在不指定类名的...
    Kevin_ZGJ阅读 264评论 0 0
  • 原型模式 有时,我们需要原原本本地为对象创建一个副本。举例来说,假设你想创建一个应用来存储、分享、编辑(比如,修改...
    英武阅读 2,200评论 1 53
  • 激情初入句,感物复长歌。 未得昔无奈,已成今若何。 并非心寂寞,总是意婆娑。 天下遍风色,采来知几多?
    雪窗_武立之阅读 170评论 2 3
  • 韶光悠悠,比落花有声,比流水无情,任谁都挡不住它匆忙的脚步,似乎只一梦醒来,眼前已不是昨日的景色。“未觉池塘春草梦...
    与敏同乐阅读 227评论 0 0