- 一、概述❤
- 二、原型设计模式的结构与写法
- 1. 结构
- 2. 实现
- 3. 案例举例
- 三、原型模式中的深克隆和浅克隆
- 四、总结
原型模式（Prototype Pattern）的简单程度仅次于单例模式和迭代器模式。正是由于简单，使用的场景才非常地多，其定义如下：
Specify the kinds of objects to create using a prototypical instance,and create new objects by copying this prototype.
（用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
非常的简单，原型模式的核心就是一个clone方法，通过该方法进行对象的拷贝。Java提供了一个Cloneable接口来表示这个对象是可以被拷贝的。但是，为什么说是“标识”？
当我们打开JDK源码发现，Cloneable是一个方法都没有的，这个接口就是一个标识作用。在JVM中具有这个表示的对象才可能被拷贝。
那怎么才能从“有可能被拷贝”转换为“可以被拷贝”呢？方法是覆盖clone()方法，是的，你没有看错是重写clone()方法。
二、原型设计模式的结构与写法 1. 结构原型模式包含如下角色：
- 抽象原型类：规定了具体原型对象必须实现的的 clone() 方法。
- 具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。
- 访问类：使用具体原型类中的 clone() 方法来复制新的对象。
我们可以定义的接口类图如下：
Cloneable 接口是上面的类图中的抽象原型类，而实现了Cloneable接口的子实现类就是具体的原型类。代码如下:
Realizetype（具体的原型类）：
public class Realizetype implements Cloneable{
public Realizetype(){
System.out.println("具体的原型对象创建完成");
}
// 这是一个克隆
@Override
protected Realizetype clone() throws CloneNotSupportedException {
System.out.println("具体的原型对象复制成功!");
return (Realizetype) super.clone();
}
}
测试类
public class Client {
public static void main(String[] args) throws CloneNotSupportedException {
// 1. 创建一个原型对象
Realizetype realizetype = new Realizetype();
// 2. 调用Realizetype类中的clone方法进行对象的克隆
Realizetype clone = realizetype.clone();
// 3. 打印出来的不是同一个对象
System.out.println(realizetype);
System.out.println(clone);
}
}
来看看结果：
首先，对于Realizetype 的构造方法只是调用了一次，说明，通过new创建对象的方式，我们只进行了一次。濫濫
而且打印出的对象不一致，所以，克隆成功。
假设有这样一个需求，用模型模式去克隆证书。
同一学校的“三好学生”奖状除了获奖人姓名不同，其他都相同，可以使用原型模式复制多个“三好学生”奖状出来，然后在修改奖状上的名字即可。
代码如下：
//奖状类
public class Citation implements Cloneable {
private String name;
public void setName(String name) {
this.name = name;
}
public String getName() {
return (this.name);
}
public void show() {
System.out.println(name + "同学：在2020学年第一学期中表现优秀，被评为三好学生。特发此状！");
}
@Override
public Citation clone() throws CloneNotSupportedException {
return (Citation) super.clone();
}
}
//测试访问类
public class CitationTest {
public static void main(String[] args) throws CloneNotSupportedException {
Citation c1 = new Citation();
c1.setName("张三");
//复制奖状
Citation c2 = c1.clone();
//将奖状的名字修改李四
c2.setName("李四");
c1.show();
c2.show();
}
}
完全没问题。
三、原型模式中的深克隆和浅克隆原型模式的克隆分为浅克隆和深克隆
-
浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。
-
深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。
而Java中的Object类中提供了clone() 方法来实现浅克隆。
举个例子：还是上面的示例，将上面的“三好学生”奖状的案例中Citation类的name属性修改为Student类型的属性。代码如下:
//奖状类
public class Citation implements Cloneable {
private Student stu;
public Student getStu() {
return stu;
}
public void setStu(Student stu) {
this.stu = stu;
}
void show() {
System.out.println(stu.getName() + "同学：在2020学年第一学期中表现优秀，被评为三好学生。特发此状！");
}
@Override
public Citation clone() throws CloneNotSupportedException {
return (Citation) super.clone();
}
}
//学生类
public class Student {
private String name;
private String address;
public Student(String name, String address) {
this.name = name;
this.address = address;
}
public Student() {
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
//测试类
public class CitationTest {
public static void main(String[] args) throws CloneNotSupportedException {
Citation c1 = new Citation();
Student stu = new Student("张三", "西安");
c1.setStu(stu);
//复制奖状
Citation c2 = c1.clone();
//获取c2奖状所属学生对象
Student stu1 = c2.getStu();
stu1.setName("李四");
//判断stu对象和stu1对象是否是同一个对象
System.out.println("stu和stu1是同一个对象？" + (stu == stu1));
c1.show();
c2.show();
}
}
发现，进行了克隆操作之后，对象里的非基本类型指向的还是同一个对象。✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨
stu对象和stu1对象是同一个对象，就会产生将stu1对象中name属性值改为“李四”，两个Citation（奖状）对象中显示的都是李四。这就是浅克隆的效果，对具体原型类（Citation）中的引用类型的属性进行引用的复制。
解决浅克隆的方式有很多，这里我只是通过常见的一种方式，使用序列化和反序列化的方式来实现深克隆。
代码如下：
public class CitationTest {
public static void main(String[] args) throws Exception {
// 1. 创建原型对象
Citation citation1 = new Citation();
// 2. 创建一个people对象
People people = new People();
people.setName("zhangsan");
citation1.setPeople(people);
// 创建对象输出流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\Users\fangshaolei\Desktop\a.txt"));
// 写对象
oos.writeObject(citation1);
// 释放资源
oos.close();
// 读取对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\Users\fangshaolei\Desktop\a.txt"));
// 读取对象
Citation citation2 = (Citation) ois.readObject();
ois.close();
citation2.getPeople().setName("wangwu");
System.out.println(citation1.getPeople().getName());
System.out.println(citation2.getPeople().getName());
}
}
运行结果是：
说明，实现了深克隆。
盧原型模式的使用场景适用于当对象的创建非常复杂的情况下，我们可以使用原型模式快捷的创建对象。或者是对性能和安全要求比较高。
优点是：
原型模式允许在运行时动态改变具体的实现类型。原型模式可以在运行期间，由客户来注册符合原型接口的实现类型，也可以动态地改变具体的实现类型，看起来接口没有任何变化，但其实运行的已经是另外一个类实例了。因为克隆一个原型就类似于实例化一个类
缺点是：
原型模式最主要的缺点是每一个类都必须配备一个克隆方法。配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类来说不是很难，而对于已经有的类不一定很容易，特别是当一个类引用不支持序列化的间接对象，或者引用含有循环结构的时候。
Notice: 本文的所有代码都已提交到GitHub仓库：原型设计模式（Prototype Pattern）-GitHub Link
参考：
设计模式之禅——原型模式的定义
《JAVA与模式》之原型模式
阎宏博士的《JAVA与模式》
