原型模式

概念:

原型设计是创建模式的一种,提供一种对象的创建机制。允许一个已经创建的实例作为原型,通过复制该原型对象来创建一个和原型相同或相似的新对象

提问:假设你有一个对象,并且想要创建它的一个副本,你会怎么做?

会想到直接new一个对象。Java中的Object类提供了浅克隆的clone,具体原型类只要实现 Cloneable 接口就可实现对象的克隆。Cloneable 只是一个标志接口而已,用来标志该类是否有克隆功能.

克隆的对象可能包含一些已经修改过的属性,保留着你想克隆对象的值,而new出来的对象的属性全是一个新的对象,对应的属性没有值,所以我们还要重新给这个对象赋值。即当需要一个新的对象来保存当前对象的“状态”就靠clone方法了。

结构:

原型模式包含如下角色:

  • 抽象原型类:规定了具体原型对象必须实现的的 clone() 方法。
  • 具体原型类:实现抽象原型类的 clone() 方法,它是可被复制的对象。
  • 访问类:使用具体原型类中的 clone() 方法来复制新的对象。

实现

原型模式的克隆分为浅克隆和深克隆,也叫浅拷贝和深拷贝。

浅克隆:创建一个新对象,新对象的属性和原来对象完全相同,克隆时把值复制一份。修改时不会影响其原来的值。但是对于引用类型,复制的是其引用地址,修改时连同原来的一起修改了。

深克隆:创建一个新对象,属性中引用的其他对象也会被克隆,不再指向原有对象地址。

image-20220814211825822

Java中的Object类中提供了 clone() 方法来实现浅克隆。 Cloneable 接口是上面的类图中的抽象原型类,而实现了Cloneable接口的子实现类就是具体的原型类。代码如下:

Realizetype(具体的原型类):

1
2
3
4
5
6
7
8
9
10
11
12
public class Realizetype implements Cloneable {

public Realizetype() {
System.out.println("具体的原型对象创建完成!");
}

@Override
protected Realizetype clone() throws CloneNotSupportedException {
System.out.println("具体原型复制成功!");
return (Realizetype) super.clone();
}
}

PrototypeTest(测试访问类):

1
2
3
4
5
6
7
8
public class PrototypeTest {
public static void main(String[] args) throws CloneNotSupportedException {
Realizetype r1 = new Realizetype();
Realizetype r2 = r1.clone();

System.out.println("对象r1和r2是同一个对象?" + (r1 == r2));
}
}

我们先来看一个案例:在学生时代,我们都梦想着拿各种奖项,每当自己拿到荣誉证书都非常开心。这种证书一般都格式比较固定。比如:

img

按这种模板来的话,其他信息几乎一致。只有名称需要改动。这时候我们用原型模式是非常方便的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
public class prototypeDemo {

public static void main(String[] args) throws CloneNotSupportedException {
Diploma dma = new Diploma("张三", "一", "Oracle", "10", "10");
System.out.println(dma.toString());
//原型模式,提供一个clone方法,只需要改变名称,其他完全一致!
Diploma dma2 = (Diploma) dma.clone();
dma2.setName("李四");
System.out.println(dma2.toString());
}
}

//奖状模板
class Diploma implements Cloneable{

String name; //姓名
String term; //学期
String school; //学校
String month; //颁发月份
String date; //颁发日期

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public Diploma(String name,String term,String school,String month,String date){
this.name = name;
this.term = term;
this.school = school;
this.month = month;
this.date = date;
}

@Override
protected Object clone() throws CloneNotSupportedException {
return (Diploma)super.clone();
}

@Override
public String toString() {
StringBuffer sb = new StringBuffer();
sb.append(this.name+"_同学:\n");
sb.append(" 在2020-2021年度第"+this.term+"学期,因平时与同学团结友爱、对学习认\n");
sb.append("真努力、对老师尊师守纪,经所有同学与老师的认证,被评为:\n");
sb.append(" 三好学生\n");
sb.append("\n特发次奖,以兹鼓励\n");
sb.append(" "+this.school+"中心学校\n");
sb.append(" "+" 二零二零年"+this.month+"月"+this.date+"日");
return sb.toString();
}

}

案例效果:

image-20220814214335553

参照:

(65条消息) 深克隆(深拷贝)和浅克隆(浅拷贝)_-R-R-的博客-CSDN博客_深克隆

模式的优缺点

  • 优点

java提供了对象的clone方法,比直接new一个对象更加优良。比如:比如我们有一个从数据库加载数据的对象。现在我们需要在我们的程序中多次修改这些数据,所以使用new关键字创建对象并再次从数据库中加载所有数据并不是一个好主意。

更方便的处理复杂的对象,获得继承的替代方案。

  • 缺点

克隆深层次引用的复杂对象比较麻烦。

克隆方法位于类的内部,对已有类的改造需要修改代码,违背了开闭原则。

使用场景

1)创建对象成本比较大(比如:初始化时间比较长,占用太多的CPU资源等),新的对象可以通过原型模式对已有对象进行赋值来获取,如果相似对象,则可以对其成员变量稍作修改即可。

2)系统想保存对象的状态,而对象的状态变化很小,或者对象占用内存较少的,可以使用原型模式配合备忘录模式来实现。