一、概述
原型模式(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() 方法来复制新的对象。
我们可以定义的接口类图如下:
2. 实现
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创建对象的方式,我们只进行了一次。
而且打印出的对象不一致,所以,克隆成功。
3. 案例举例
假设有这样一个需求,用模型模式去克隆证书。
同一学校的“三好学生
”奖状除了获奖人姓名不同,其他都相同,可以使用原型模式复制多个“三好学生”奖状出来,然后在修改奖状上的名字即可。
代码如下:
//奖状类
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与模式》