一、前言
原型模式是一种创建型设计模式，它允许在运行时通过克隆现有对象来创建新对象，而不是通过常规的构造函数创建。在原型模式中，一个原型对象可以克隆自身来创建新的对象，这个过程可以通过深度克隆或浅克隆来实现。简单说原型模式其实就是从一个对象再创建另外一个可定制的对象，而且不需知道任何创建的细节。
原型模式包含三个角色：
①Prototype（抽象原型类）：定义用于克隆自身的接口，通常是一个抽象类或接口，其中声明了一个克隆方法 clone()，用于创建一个新的对象，具体的克隆操作由子类实现。
②ConcretePrototype（具体原型类）：实现 Prototype 接口，实现 clone() 方法，完成对象的克隆操作。每个具体原型类都有自己的一些属性和方法，不同的具体原型类之间具有不同的实现方式。
③Client（客户类）：使用原型模式创建新的对象，在原型模式中，客户端通过克隆接口来创建新的对象，而不是通过实例化的方式。客户端需要获取一个原型对象，并通过克隆方法来创建新的对象，从而避免了创建新对象的开销。
原型模式的克隆分为浅拷贝和深拷贝两种。
二、浅拷贝
创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。
这里抽象原型类不用自己创建，都是Object，里面有clone()方法：
具体原型类实现Cloneable，里面重写clone方法，直接super调用父类的clone方法即可：
import java.util.List;
/**
* @Author dengyifan
* @create 2023/11/10 10:19
* @description
*/
public class UserPrototype implements Cloneable{
private String name;
private Integer age;
private List<String> messages;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public List<String> getMessages() {
return messages;
}
public void setMessages(List<String> messages) {
this.messages = messages;
}
@Override
protected UserPrototype clone() throws CloneNotSupportedException {
return (UserPrototype) super.clone();
}
}
客户类：
import java.util.ArrayList;
import java.util.List;
/**
* @Author dengyifan
* @create 2023/11/10 10:22
* @description
*/
public class PrototypeClient {
public static void main(String[] args) throws CloneNotSupportedException {
UserPrototype userPrototype1 = new UserPrototype();
userPrototype1.setName("tom");
userPrototype1.setAge(18);
List<String> messages1 = new ArrayList<>();
messages1.add("test");
userPrototype1.setMessages(messages1);
UserPrototype userPrototype2 = userPrototype1.clone();
System.err.println(String.format("两个对象是否一致：%s", userPrototype1 == userPrototype2));
System.err.println(String.format("两个对象的name属性是否一致：%s", userPrototype1.getName() == userPrototype2.getName()));
System.err.println(String.format("两个对象的messages属性是否一致：%s", userPrototype1.getMessages() == userPrototype2.getMessages()));
System.err.println(userPrototype1.getMessages());
System.err.println(userPrototype2.getMessages());
messages1.clear();
messages1.add("test1");
System.err.println(userPrototype1.getMessages());
System.err.println(userPrototype2.getMessages());
}
}运行结果：
通过结果可以看到，通过克隆的对象与原型对象的引用不一致，说明再内存中存在两个不同的对象，一个是原型对象，一个是克隆生成的对象。而这里属性都显示是一致的，结果都是true，说明两个对象的成员对象是同一个，也就是对象本身是复制了，但是其成员的对象再内存中没有复制。并且我们修改原型的messages属性，克隆对象的messages也跟着改变，说明属性确实是同一个对象的引用。
三、深拷贝
深拷贝中除了原型对象与克隆生成的对象被复制以外，里面的属性也需要被复制，即地址都不一样。这里深拷贝实现了Serializable，即进行了序列化。
import java.io.*;
import java.util.List;
/**
* @Author dengyifan
* @create 2023/11/10 15:43
* @description
*/
public class UserPrototypeDeep implements Serializable {
private String name;
private Integer age;
private List<String> messages;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public List<String> getMessages() {
return messages;
}
public void setMessages(List<String> messages) {
this.messages = messages;
}
protected UserPrototypeDeep deepClone() throws Exception{
ByteArrayOutputStream bao=new ByteArrayOutputStream();
ObjectOutputStream oos=new ObjectOutputStream(bao);
oos.writeObject(this);
//将对象从流中取出
ByteArrayInputStream bis=new ByteArrayInputStream(bao.toByteArray());
ObjectInputStream ois=new ObjectInputStream(bis);
return (UserPrototypeDeep) ois.readObject();
}
}import java.util.ArrayList;
import java.util.List;
/**
* @Author dengyifan
* @create 2023/11/10 15:46
* @description
*/
public class PrototypeDeepClient {
public static void main(String[] args) throws Exception {
UserPrototypeDeep userPrototypeDeep1 = new UserPrototypeDeep();
userPrototypeDeep1.setAge(19);
userPrototypeDeep1.setName("tom");
List<String> messages1 = new ArrayList<>();
messages1.add("test");
userPrototypeDeep1.setMessages(messages1);
UserPrototypeDeep userPrototypeDeep2 = userPrototypeDeep1.deepClone();
System.err.println(String.format("两个对象是否一致：%s", userPrototypeDeep1 == userPrototypeDeep2));
System.err.println(String.format("两个对象的name属性是否一致：%s", userPrototypeDeep1.getName() == userPrototypeDeep2.getName()));
System.err.println(String.format("两个对象的messages属性是否一致：%s", userPrototypeDeep1.getMessages() == userPrototypeDeep2.getMessages()));
System.err.println(userPrototypeDeep1.getMessages());
System.err.println(userPrototypeDeep2.getMessages());
messages1.clear();
messages1.add("test1");
System.err.println(userPrototypeDeep1.getMessages());
System.err.println(userPrototypeDeep2.getMessages());
}
}
运行结果：
可以看出除了对象本身不一致以外，里面的属性也不一致，当修改原型对象里面引用对象的属性时，克隆对象的属性不会发生变化，即也证明属性不是同一个对象。
对于原型模式的应用场景，主要有以下几点：
1. 当对象的创建过程非常复杂或耗费大量资源时，可以使用原型模式来复制一个现有对象，从而避免重复创建对象。
2. 当需要创建多个相似的对象时，可以使用原型模式来减少重复代码，提高代码的重用性。
3. 当创建对象的过程需要大量的数据准备或配置时，可以使用原型模式来复制一个已经配置好的对象，从而避免重复的数据准备或配置过程。
4. 当需要动态生成对象的子类时，可以使用原型模式来复制一个已有的对象，并对其进行修改，从而避免重新编写子类的代码。
5. 当需要保护对象的状态时，可以使用原型模式来创建对象的副本，并将副本交给其他对象使用，从而避免原始对象的状态被修改。
