设计模式-原型模式
在阎宏博士的《JAVA与模式》一书中开头是这样描述原型（Prototype）模式的：(学习)
原型模式属于对象的创建模式。通过给出一个原型对象来指明所有创建的对象的类型，然后用复制这个原型对象的办法创建出更多同类型的对象。这就是选型模式的用意。
原型模式的结构
原型模式要求对象实现一个可以“克隆”自身的接口，这样就可以通过复制一个实例对象本身创建一个新的实例。这样一来，通过原型实例创建新的对象，就不再需要关心这个实例本身的类型，只要实现了克隆自身的方法，就可以通过这个方法来获取新的对象，而无顺再去通过new来创建。
原型模式有两种表现形式：(1) 简单形式 (2)登记形式，这两种表现形式仅仅是原型模式的不同实现。
简单形式的原型模式
这种形式涉及到三个角色：
- 客户(Client)角色：客户类提出创建对象的请求。
- 抽象原型(Prototype)角色：这是一个抽象角色，通常由一个接口或者抽象类实现。此角色给出所有的具体原型类所需的接口。
- 具体原型(ConcretePrototype)角色：被复制的对象。此角色需要实现抽象的原型角色所要求的接口。
源代码
package Prototype /** * 抽象原型角色 * */ interface Prototype { /** * 克隆自身的方法 * @return 一个从自身克隆出来的对象 * */ fun clone(): Any//Kotlin 中使用 Any 时，它会被编译成 Java 字节码中的 Object }
package Prototype /** * 具体原型角色 * */ class ConcretePrototype1 : Prototype { override fun clone(): Any { //最简单的克隆，新建一个自身对象，由于没有属性就不需要复制了 val prototype1 = ConcretePrototype1() return prototype1 } }
package Prototype /** * 具体原型角色 * */ class ConcretePrototype2 : Prototype { override fun clone(): Any { //最简单的克隆，新建一个自身对象，由于没有属性就不需要复制了 val prototype2 = ConcretePrototype2() return prototype2 } }
package Prototype /** * 客户端角色 * */ class Client constructor(prototype_: Prototype) { //持有需要使用的原型接口对象 private var prototype: Prototype? = null init { this.prototype = prototype_ } fun opreation(example: Prototype) { //需要创建原型接口的对象 val copyPrototype = prototype?.clone() } }
登记形式的原型模式
作为原型模式的第二种形式，它多了一个原型管理器(PrototypeManager)角色，该角色的作用是：创建具体原型类的对象，并记录每一个被创建的对象。
源代码
package Prototype.register /** * 登记形式的原型模式 * 抽象原型角色 * */ interface Prototype { fun clone(): Any fun getName(): String fun setName(name: String) }
package Prototype.register /** * 具体原型角色 * */ class ConcretePrototype1 : Prototype { private var name: String = "" override fun clone(): Any { val concretePrototype1 = ConcretePrototype1() concretePrototype1.setName(name) return concretePrototype1 } override fun toString(): String { return "now is Prototype1, name:$name" } override fun getName(): String { return name } override fun setName(name: String) { this.name = name } }
package Prototype.register /** * 具体原型角色 * */ class ConcretePrototype2 : Prototype { private var name: String = "" override fun clone(): Any { val concretePrototype2 = ConcretePrototype2() concretePrototype2.setName(name) return concretePrototype2 } override fun toString(): String { return "now is Prototype2, name:$name" } override fun getName(): String { return name } override fun setName(name: String) { this.name = name } }
原型管理角色保持一个聚集，作为对所有原型对象的登记，这个角色提供必要的方法，供外界增加新的原型对象和取得已登记过的原型对象。
package Prototype.register /** * 原型管理器角色 * */ class PrototypeManager { companion object { //用来记录原型的编号与原型实例的对应关系 private val map = HashMap<String, Prototype>() /** * 向原型管理器添加或修改某个原型注册 * @param prototypeId 原型编号 * @param prototype 原型实例 * */ @Synchronized fun setPrototype(prototypeId: String, prototype: Prototype) { map[prototypeId] = prototype } /** * 向原型管理器删除某个原型注册 * @param prototypeId 原型编号 * */ @Synchronized fun removePrototype(prototypeId: String) { map.remove(prototypeId) } /** * 获取某个原型编号对应的原型实例 * @param prototypeId 原型编号 * @return 原型实例 * @throws Exception 如果原型编号对应的实例不存在，则抛出异常 * */ @Synchronized @Throws(Exception::class) fun getPrototype(prototypeId: String): Prototype { return map[prototypeId] ?: throw Exception("您希望获取的原型还没有注册或已被销毁") } } }
客户端运行：
val p1 = ConcretePrototype1() PrototypeManager.setPrototype("p1",p1) //获取原型来创建对象 val p3 = PrototypeManager.getPrototype("p1").clone() as Prototype p3.setName("张3") println("第一个实例:$p3") //动态的切换了实现 val p2 = ConcretePrototype2() PrototypeManager.setPrototype("p1",p2) //重新获取原型来创建对象 val p4 = PrototypeManager.getPrototype("p1").clone() as Prototype p4.setName("李4") println("第二个实例:$p4") //注销了原型 PrototypeManager.removePrototype("p1") try { //再次获取原型来创建对象 val p5 = PrototypeManager.getPrototype("p1").clone() as Prototype p5.setName("王5") println("第三个实例:$p5") } catch (ex:Exception){ println(ex) }
运行结果：
第一个实例:now is Prototype1, name:张3
第二个实例:now is Prototype2, name:李4
java.lang.Exception: 您希望获取的原型还没有注册或已被销毁
两种形式的比较
简单形式和登记形式的原型模式各有其长处和短处。
如果需要创建的原型对象数目较少而且比较固定的话，可以采取第一种形式。在这种情况下，原型对象的引用可以由客户端自已保存。
如果要创建的原型对象数目不固定的话，可以采取第二种形式。在这种情况下，客户端不保存对原型对象的引用，这个任务被交给管理员对象。在复制一个原型对象之前，客户端可以查看管理员对象是否已经有一个满足要求的原型对象。如果有，可以直接从管理员类取得这个对象引用；如果没有，客户端就需要自行复制此原型对象。
Java中的克隆方法
Java的所有类都是从java.lang.Object类继承而来的，而Object类提供protected Object clone()方法对对象进行复制，子类当然也可以把这个方法置换掉，提供满足自已需要的复制方法。对象的复制有一个基本问题，就是对象通常都有对其它对象的引用。当使用Object类的clone()方法来复制一个对象时，此对象对其它对象的引用也同时会被复制一份。
Java语言提供的Cloneable接口只起一个作用，就是在运行时期通知JVM可以安全地在这个类上使用clone()方法。通过调用这个clone()方法可以得到一个对象的复制。由于Object类本身并不实现Cloneable接口，因此如果所考虑的类没有关现Cloneable接口时，调用clone()方法会抛出CloneNotSupportedException异常。
克隆满足的条件
clone()方法将对象复制了一份并返还给调用者。所谓“复制”的含义与clone()方法是怎么实现的。一般而言，clone()方法满足以下的描述：
- 对任何的对象x，都有: x.clone() != x。换言之，克隆对象与原对象不是同一个对象。
- 对任何的对象x，都有: x.clone().getClass() == x.getClass()，换言之，克隆对象与原形对象的类型一样。
- 如果对象x的equals()方法定义其恰当的话，那么x.clone().euals(x)应当成立的。
在java语言的api中，凡是提供了clone()方法的类，都满足上面的这些条件。java语言的设计师在设计自已的clone()方法时，也应当遵守着三个条件。一般来说，上面的三个条件中的前两个是必需要的，而第三个是可选的。
浅克隆与深克隆
无论你是自已实现克隆方法，还是采用java提供的克隆方法，都存在一个浅度克隆和深度克隆的问题。
- 浅度克隆
只负责克隆按值传递的数据（比如基本数据类型、String类型），而不复制它所引用的对象，换言之，所有的对其它对象的引用都仍然指向原来的对象。
- 深度克隆
除了浅克隆要克隆值外，还负责克隆引用类型的数据。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深度克隆把要复制的对象所引用的对象都复制了一遍，而这种对被引用到的对象的复制叫做间接复制。
深度克隆要深入到多少层，是一个不易确定的问题。在决定以深度克隆的方式复制一个对象的时候，必顺决定对间接复制的对象时采取浅度克隆还是继续采用深度克隆。因此，在采取深度克隆时，需要决定多深才算深。此外，在深度克隆的过程中，很可能会出现循环引用的问题，必顺小心处理。
原型模式的优点
原型模式允许在运行时动态改变具体的实现类型。原型模式可以在运行期间，由客户来注册符合原型接口的实现类型，也可以动态地改变具体的实现类型，看起来接口没有任何变化，但其实运行的已经是另外一个类实例了。因此克隆一个原型就类似于实例化一个类。
原型模式的缺点
原型模式最主要的缺点是每一个类都必顺配备一个克隆方法。配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类来说不是很难，而对于全新的类来说不是很难，而对于已经有的类不一定很容易，特别是当一个类引用不支持序列化的间接对象，或者引用含有循环结构的时候。
