介绍
原型模式(Prototype Pattern) - 用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象
原型模式(Prototype Pattern)是一个比较简单的创建型设计模式，它的重点在于克隆，也就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象
原型模式结构
原型方法模式的角色及职责
- 客户(Client)：提出创建对象的请求，使用复制对象的方法创建新实例
- 抽象原型(Abstract Prototype)：定义所有的具体原型类所需的复制方法，接口或抽象类
- 具体原型(Concrete Prototype)：被克隆、复制的对象，此角色需要实现抽象的原型角色所要求的接口
原型模式通用类图
原型模式实现
在Java中实现原型模式特别简单，只要两步即可
- 实现
Cloneable接口 - 重写
clone()方法
public class PrototypeClass implements Cloneable{
@Override
protected PrototypeClass clone() throws CloneNotSupportedException {
return (PrototypeClass)super.clone();
}
}
原型模式已经与Java融为一体，Object类提供了一个
clone()方法，且是native方法（本地原生方法，C/C++实现），所以所有类都可以通过重写Object的clone()方法或者调用clone()方法来实现对对象的克隆不过要实现克隆的类还必须实现
Cloneable接口，Cloneable是一个标识接口，表明该对象可以复制，如果没有实现该接口却调用Object的clone()方法，会抛出CloneNotSupportedException异常
我们再为上面的类添加一些成员变量，看一下再执行克隆方法的情况
public class PrototypeClass implements Cloneable{
private String name;
private List<String> list = new ArrayList<>();
@Override
protected PrototypeClass clone() throws CloneNotSupportedException {
return (PrototypeClass)super.clone();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<String> getList() {
return list;
}
public void setList(List<String> list) {
this.list = list;
}
@Override
public String toString() {
return "[name: " + name + ", list: " + list.toString() + "]";
}
}
测试
@Test
public void test() throws CloneNotSupportedException {
PrototypeClass p1 = new PrototypeClass();
p1.setName("zhangsan");
p1.getList().add("zhangsan");
System.out.println("p1 " + p1.toString());
PrototypeClass p2 = p1.clone();
p2.setName("lisi");
p2.getList().add("lisi");
System.out.println("p2 " + p2.toString());
System.out.println("p1 " + p1.toString());
}
测试结果
p1 [name: zhangsan, list: [zhangsan]]
p2 [name: lisi, list: [zhangsan, lisi]]
p1 [name: zhangsan, list: [zhangsan, lisi]]
从上面的结果我们可以发现，当我们对克隆对象p2的引用类型的成员变量进行修改时，p1的list变量也改变了，这说明原始对象和克隆对象的list变量指向的是同一个对象。为什么会这样呢？
原来clone()方法只是复制成员变量的值，也就是说如果成员变量是值类型（基本数据类型和String），会复制值，而如果是引用类型，则只会复制引用但不会复制引用所指向的对象，这种复制叫做浅复制。两个对象会共享一个私有的变量，大家都能修改，这是不安全的，那是不是还有更深入的复制呢？
浅复制和深复制
浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的
深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底
我们通过直接调用Object的clone()便可以实现浅复制，但是引用地址只是复制了它的引用，那么我们想复制它指向的对象，是不是可以对成员变量也调用clone()方法复制一遍
public class PrototypeClass implements Cloneable {
private String name;
private ArrayList<String> list = new ArrayList<>();
@Override
protected PrototypeClass clone() throws CloneNotSupportedException {
PrototypeClass newPrototypeClass = (PrototypeClass) super.clone();
newPrototypeClass.list = (ArrayList<String>) this.list.clone();
return newPrototypeClass;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public ArrayList<String> getList() {
return list;
}
public void setList(ArrayList<String> list) {
this.list = list;
}
@Override
public String toString() {
return "[name: " + name + ", list: " + list.toString() + "]";
}
}
测试
@Test
public void test() throws CloneNotSupportedException {
PrototypeClass p1 = new PrototypeClass();
p1.setName("zhangsan");
p1.getList().add("zhangsan");
System.out.println("p1 " + p1.toString());
PrototypeClass p2 = p1.clone();
p2.setName("lisi");
p2.getList().add("lisi");
System.out.println("p2 " + p2.toString());
System.out.println("p1 " + p1.toString());
}
测试结果
p1 [name: zhangsan, list: [zhangsan]]
p2 [name: lisi, list: [zhangsan, lisi]]
p1 [name: zhangsan, list: [zhangsan]]
使用序列化实现深复制
使用序列化实现深复制，采用流的形式读入当前对象的二进制输入，再写出二进制数据对应的对象
public class PrototypeClassSerialize implements Serializable {
private String name;
private ArrayList<String> list = new ArrayList<>();
/**
* 深复制 需要采用流的形式读入当前对象的二进制输入，再写出二进制数据对应的对象
*/
public Object deepClone() throws IOException, ClassNotFoundException {
// 将对象序列化到二进制流
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
// 从二进制流中读出产生的新对象
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return ois.readObject();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public ArrayList<String> getList() {
return list;
}
public void setList(ArrayList<String> list) {
this.list = list;
}
@Override
public String toString() {
return "[name: " + name + ", list: " + list.toString() + "]";
}
}
测试
@Test
public void test() throws IOException, ClassNotFoundException {
PrototypeClassSerialize p1 = new PrototypeClassSerialize();
p1.setName("zhangsan");
p1.getList().add("zhangsan");
System.out.println("p1 " + p1.toString());
PrototypeClassSerialize p2 = (PrototypeClassSerialize) p1.deepClone();
p2.setName("lisi");
p2.getList().add("lisi");
System.out.println("p2 " + p2.toString());
System.out.println("p1 " + p1.toString());
}
测试结果
p1 [name: zhangsan, list: [zhangsan]]
p2 [name: lisi, list: [zhangsan, lisi]]
p1 [name: zhangsan, list: [zhangsan]]
