【从0开始学设计模式-6| 原型模式】
一个月没更新了，在找实习。。
其实还是懒了，其实每天花个半小时左右就能写一篇博客的。。。
概念
原型模式(Prototype Pattern)设计出来的目标就是：通过本体复制出与本体一样的分身（分身具有本体一样特性）
定义：使用原型实例指定要创建的对象的种类，并通过复制此原型来创建新对象。
首先，应该注意原型模式不是用来获得性能优势的。它仅用于从原型实例创建新对象。
原型模式的结构
在原型模式结构图中包含如下几个角色：
Prototype（抽象原型类）：声明克隆方法的接口，是所有具体原型类的公共父类，可以是抽象类也可以是接口，甚至还可以是具体实现类。ConcretePrototype（具体原型类）：它实现在抽象原型类中声明的克隆方法，在克隆方法中返回自己的一个克隆对象。Client（客户类）：让一个原型对象克隆自身从而创建一个新的对象，在客户类中只需要直接实例化或通过工厂方法等方式创建一个原型对象，再通过调用该对象的克隆方法即可得到多个相同的对象。由于客户类针对抽象原型类Prototype编程，因此用户可以根据需要选择具体原型类，系统具有较好的可扩展性，增加或更换具体原型类都很方便。
原型式的实现
关键就是：浅克隆（浅复制）和深克隆（深复制）之间的区别
类图设计
Level是一个关卡，我们的目的就是克隆一个关卡！
实现1：浅拷贝
Java的浅拷贝使用的是
Object类自带的clone()方法，注意使用这个方法类必须加上implements Cloneable,这相当于一个标记，否则无法使用Object.clone()方法。调用时会直接抛出CloneNotSupportedException。
关卡类以及关卡中的相关类
@DatapublicclassLevelimplementsCloneable{privateStringname;privateStringdescription;privateMonster[]monsters;//怪兽数组privateRewardsrewards;@OverridepublicLevelclone(){//重写的Object的clone方法try{//实现浅克隆return(Level)super.clone();}catch(CloneNotSupportedExceptione){System.err.println("对象不支持克隆");returnnull;}}}@Data@AllArgsConstructorpublicclassMonster{//怪兽的相关属性privateStringname;privateinthp;privateintattack;}@Data@AllArgsConstructorpublicclassRewards{//奖励privateintgold;}客户端
publicclassClient{publicstaticvoidmain(String[]args){//创建原型对象Levelproto=newLevel();proto.setName("猴王出世");proto.setDescription("让猴王成功出世，可以通关本关卡");Monster[]monsters={newMonster("小猴子",100,1),newMonster("大狮子",200,100),};proto.setMonsters(monsters);proto.setRewards(newRewards(50));//克隆Levelclone=proto.clone();//比较克隆结果System.out.println(clone==proto);//falseSystem.out.println(clone.getRewards()==proto.getRewards());//trueSystem.out.println(clone.getMonsters()[0]==proto.getMonsters()[0]);//trueclone.getRewards().setGold(60);System.out.println("原来的对象"+" "+proto.getRewards().getGold());//60System.out.println("克隆的对象"+" "+clone.getRewards().getGold());//60}}
解释
- 浅拷贝的特点
- 对于基本数据类型以及String，拷贝的是值。
String是不可变的引用对象，所以也是拷贝的值。
- 而对于引用数据类型，只拷贝了“内存地址”。也就是说克隆的对象跟原来的对象共用一套引用对象
- 例如案例中的
monsters数组和rewards对象。当克隆对象修改了引用对象的值，原对象的引用对象的值也会跟着变。上面案例中的客户端有测试这个效果。
- 例如案例中的
- 注意：拷贝出来的对象本身，是新创建的。
super.clone()会在堆内存中申请一块全新的空间。只不过里面的引用类型的成员变量monsters数组和rewards对象不是新的。
- 对于基本数据类型以及String，拷贝的是值。
- 造成这种现象的原因如下：
Object类的clone()方法默认是浅拷贝：除了基本数据类型跟String类型的变量，各自修改之后是独有的。对于其他引用类型的变量都是共享的，因为克隆的只是引用。也要注意String虽然是引用对象，但是修改之后也是独有的，是因为String被设计成了不可变
- 如何实现深拷贝呢？
- 见下文。
实现2：深拷贝（序列化、反序列化）
这是一种实现深拷贝的方式：利用序列化、反序列化
注意：这种写法要求Level以及里面的引用对象所属的类必须必须
implements Serializable，这样才能成功进行序列化、反序列化
关卡类以及关卡中的相关类
@DatapublicclassLevelimplementsSerializable{privateStringname;privateStringdescription;privateMonster[]monsters;privateRewardsrewards;publicLeveldeepClone(){try{//将对象写入到输出流中ByteArrayOutputStreamos=newByteArrayOutputStream();ObjectOutputStreamoos=newObjectOutputStream(os);//序列化：递归地遍历Level对象，把它包含的String、Monster[]数组、Rewards对象全部转换成一串连续的二进制字节流oos.writeObject(this);//将对象从输入流中取出ByteArrayInputStreamis=newByteArrayInputStream(os.toByteArray());ObjectInputStreamois=newObjectInputStream(is);//反序列化：读取这串二进制流，并在内存中重新构建出一套一模一样的对象Levelclone=(Level)ois.readObject();//关闭流os.close();oos.close();is.close();ois.close();returnclone;}catch(Exceptione){System.err.println("克隆失败");returnnull;}}}@Data@AllArgsConstructor@NoArgsConstructorpublicclassMonsterimplementsSerializable{privateStringname;privateinthp;privateintattack;}@Data@AllArgsConstructor@NoArgsConstructorpublicclassRewardsimplementsSerializable{privateintgold;}客户端
publicclassClient{publicstaticvoidmain(String[]args){//创建原型对象Levelproto=newLevel();proto.setName("猴王出世");proto.setDescription("让猴王成功出世，可以通关本关卡");Monster[]monsters={newMonster("小猴子",100,1),newMonster("大狮子",200,100),};proto.setMonsters(monsters);proto.setRewards(newRewards(50));//克隆Levelclone=proto.deepClone();//比较克隆结果System.out.println(clone==proto);//falseSystem.out.println(clone.getRewards()==proto.getRewards());//falseSystem.out.println(clone.getMonsters()[0]==proto.getMonsters()[0]);//false}}
解释重点代码
其实关键就是使用了序列化跟反序列化
//将对象写入到输出流中ByteArrayOutputStreamos=newByteArrayOutputStream();ObjectOutputStreamoos=newObjectOutputStream(os);oos.writeObject(this);//将对象从输入流中取出ByteArrayInputStreamis=newByteArrayInputStream(os.toByteArray());ObjectInputStreamois=newObjectInputStream(is);Levelclone=(Level)ois.readObject();具体流程是这样的：
new ByteArrayOutputStream();内存中开辟一块空地，专门用来存放二进制数据(字节)ObjectOutputStream是一个转换器，用来将Java对象->二进制的0、1（序列化）new ObjectOutputStream(os);是将转换器连接到内存中开辟的空地，而不是真正的在写。writeObject(this)是真正将对象写到输出流的操作，通过oos将对象转换成二进制数据然后放到开辟的空地os.toByteArray()将空地的数据变成真正的字节数组new ByteArrayInputStream(os.toByteArray());建立了一个读取通道ObjectInputStream也是一个转换器，将二进制的0、1 -> Java对象（反序列化）new ObjectInputStream(is);将转换器连接到通道(Level) ois.readObject();是真正的读取操作，在堆内存开辟新空间创建新对象，读取通道里面的数据，再通过转换器还原数据，最后放到新对象中
通过这种方式，构建出来的Monster[]数组和Rewards对象，虽然内容和原来一样，但在内存里拥有了全新的地址。
其他实现方式
这两种实现方式，是我在背小林coding的八股的时候发现的
实现 Cloneable 接口并重写 clone() 方法
要求对象及其所有引用类型字段都实现Cloneable 接口，并且重写clone() 方法。通过递归克隆引用类型字段来实现深拷贝。
classMyClassimplementsCloneable{privateStringfield1;privateNestedClassnestedObject;@OverrideprotectedObjectclone()throwsCloneNotSupportedException{// 首先调用 super.clone() 得到一个浅拷贝的对象MyClasscloned=(MyClass)super.clone();// 对内部的引用对象进行深拷贝cloned.nestedObject=(NestedClass)nestedObject.clone();// 深拷贝内部的引用对象returncloned;}}classNestedClassimplementsCloneable{privateintnestedField;@OverrideprotectedObjectclone()throwsCloneNotSupportedException{returnsuper.clone();}}手动递归复制
针对特定对象结构，手动递归复制对象及其引用类型字段
classMyClass{privateStringfield1;privateNestedClassnestedObject;publicMyClassdeepCopy(){MyClasscopy=newMyClass();copy.setField1(this.field1);copy.setNestedObject(this.nestedObject.deepCopy());//手动对引用类型的字段进行拷贝returncopy;}}classNestedClass{privateintnestedField;publicNestedClassdeepCopy(){NestedClasscopy=newNestedClass();copy.setNestedField(this.nestedField);returncopy;}}原型模式适用环境
主要优点
- 当创建新的对象实例较为复杂时，使用原型模式可以简化对象的创建过程，通过复制一个已有实例可以提高新实例的创建效率。
- 扩展性较好，由于在原型模式中提供了抽象原型类，在客户端可以针对抽象原型类进行编程，将具体原型实现类写在配置文件中，增加或减少产品类对原有系统都没有任何影响。
- 原型模式提供了简化的创建结构，工厂方法模式常常需要有一个与产品类等级结构相同的工厂等级结构，而原型模式就不需要这样，原型模式中产品的复制是通过封装在原型类中的克隆方法实现的，无须专门的工厂类来创建产品。
- 可以使用深克隆的方式保存对象的状态，使用原型模式将对象复制一份并将其状态保存起来，以便在需要的时候使用（如恢复到某一历史状态），可辅助实现撤销操作。
主要缺点
- 需要为每一个类配备一个克隆方法，而且该克隆方法位于一个类的内部，当对已有的类进行改造时，需要修改源代码，违背了“开闭原则”。
- 在实现深克隆时需要编写较为复杂的代码，而且当对象之间存在多重的嵌套引用时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现起来可能会比较麻烦。
适用环境
在以下情况下可以考虑使用原型模式：
- 创建新对象成本较大（如初始化需要占用较长的时间，占用太多的CPU资源或网络资源），新的对象可以通过原型模式对已有对象进行复制来获得，如果是相似对象，则可以对其成员变量稍作修改。
- 如果系统要保存对象的状态，而对象的状态变化很小，或者对象本身占用内存较少时，可以使用原型模式配合备忘录模式来实现。
- 需要避免使用分层次的工厂类来创建分层次的对象，并且类的实例对象只有一个或很少的几个组合状态，通过复制原型对象得到新实例可能比使用构造函数创建一个新实例更加方便。
说一下例子，进一步理解原型模式的使用场景
有时候，一个对象的可重用性不在于它的类定义，而在于它当前的状态。
- 示例：在游戏开发中，你创建了一个“精英怪”。这个怪物的血量、护甲、装备和 AI 状态都是在游戏运行中动态计算出来的。
- 痛点：如果你想要再生成一个一模一样的精英怪，通过
new一个新对象再挨个属性赋值（setHealth,setArmor…）太繁琐且易错。- 原型方案：直接
enemy.clone()，瞬间得到一个状态完全一致的副本。
如果这篇文章对你有帮助，欢迎点赞、评论、关注、收藏。你们的支持是我前进的动力！