原型模式

原型模式

定义

使用原型实例指定创建对象的种类,并且通过克隆这些原型创建新的对象。原型模式是一种对象创建型模式。

定义很明确了,原型模式最重要的就是原型实例的克隆方法,通过克隆快速生成与原型实例相似的实例。

UML图

通过UML图可以看出原型实例主要有下面几个角色:

  1. 抽象原型实例(Prototype):这个是个抽象角色,可以是抽象类、接口甚至是一般类,主要规范所有具体原型实例所必需的方法。
  2. 具体原型实例(ConcretePrototype):最主要的是要实现复制方法。

代码

根据UML编写代码如下

1
2
3
4
5
public interface Prototype {

public Prototype clone();

}
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
public class ConcretePrototypeA implements Prototype {
private String atts;

public String getAtts() {
return atts;
}

public void setAtts(String atts) {
this.atts = atts;
}

@Override
public String toString() {
return "ConcretePrototypeA{" +
"atts='" + atts + '\'' +
'}';
}

@Override
public boolean equals(Object obj) {
if (obj instanceof ConcretePrototypeA) {
ConcretePrototypeA concretePrototypeA = (ConcretePrototypeA) obj;
return atts.equals(concretePrototypeA.getAtts());
}
return super.equals(obj);
}

@Override
public Prototype clone() {
ConcretePrototypeA prototypeA = new ConcretePrototypeA();
prototypeA.setAtts(this.atts);
return prototypeA;
}
}

客户端测试代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Client {

public static void main(String[] args){

ConcretePrototypeA concretePrototypeA = new ConcretePrototypeA();
concretePrototypeA.setAtts("Test");

ConcretePrototypeA clone1 = (ConcretePrototypeA) concretePrototypeA.clone();
ConcretePrototypeA clone2 = (ConcretePrototypeA) concretePrototypeA.clone();

System.out.println("是否是同一个对象? "+(clone1==clone2));
System.out.println("对象的值是否相同? "+clone1.equals(clone2));
}
}

可以看到,我重写了ConcretePrototypeA类的equals()方法,当两个对象的值相同时返回true,测试运行结果如下:

1
2
是否是同一个对象? false
对象的值是否相同? true

从结果可知ConcretePrototypeA通过clone()方法在内存中创建了两个新的相似的实例,这个就是原型模式的核心了,通用于各种语言。

Java中的原型模式

看见clone()方法,相信不少童鞋都觉得很熟悉,没错,在Java中所有的类都继承自Object类,而Object类中就存在clone()这个方法,所以在Java中我们可以省去自己创建抽象原型实例,因为Object就充当了抽象原型实例的角色。

下面还是用一个示例来演示吧,看了好多童鞋都喜欢用大圣的例子,毫毛变幻出猴子猴孙,这明明就是典型的圆形模式嘛,哈哈,那就再来一个大圣吧。

UML图

注意:Java 重写clone()方法需要实现Cloneable

代码

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
//大圣
public class MonkeyKing implements Cloneable {

private int height;

private int weight;

private int age;

public MonkeyKing(int height, int weight, int age) {
this.height = height;
this.weight = weight;
this.age = age;
}

//get set 方法
...

@Override
protected Object clone() {
MonkeyKing monkeyKing = null;
try {
monkeyKing = (MonkeyKing) super.clone();
return monkeyKing;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return monkeyKing;
}
}
}

客户端代码

1
2
3
4
5
6
7
8
9
10
public class Client {

public static void main(String[] args) {
MonkeyKing monkeyKing = new MonkeyKing(180, 75, 500);

MonkeyKing copyMonkey = (MonkeyKing) monkeyKing.clone();

System.out.println("是同一个大圣? "+(monkeyKing == copyMonkey));
}
}

运行结果

1
是同一个大圣? false

OK!成功复制一个大圣!

等等!我们是不是忘了大圣的武器了!

赶紧赶紧给大圣配上武器!如意金箍棒!!!可大可小,可粗可细 →_→

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//金箍棒
public class GoldHoopStick {

private float height = 100.0f;

private float weight = 50.0f;

/**
* 放大 每次放大一倍
*/
public void grow() {
height = height * 2;
weight = weight * 2;
}

/**
* 缩小 每次缩小一半
*/
public void shrink() {
height = height / 2;
weight = weight / 2;
}
}

修改MonkeyKing代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class MonkeyKing implements Cloneable {

...

private GoldHoopStick goldHoopStick;

public MonkeyKing(int height, int weight, int age) {
this.height = height;
this.weight = weight;
this.age = age;
goldHoopStick = new GoldHoopStick();
}

public GoldHoopStick getGoldHoopStick() {
return goldHoopStick;
}

...
}

修改客户端代码

1
2
3
4
5
6
7
8
9
10
11
public class Client {

public static void main(String[] args) {
MonkeyKing monkeyKing = new MonkeyKing(180, 75, 500);

MonkeyKing copyMonkey = (MonkeyKing) monkeyKing.clone();

System.out.println("是同一个大圣? " + (monkeyKing == copyMonkey));
System.out.println("是同一根棒子吗? " + (monkeyKing.getGoldHoopStick() == copyMonkey.getGoldHoopStick()));
}
}

运行测试结果如下

1
2
是同一个大圣? false
是同一根棒子吗? true

这里为什么是同一根棒子呢?难道这根伸缩自如的棒子这么特殊,上天下地只此一根??

怎么可能!自己创建的类还能不听自己使唤?

其实这里就牵扯到Java中的另两个知识 —- 深克隆与浅克隆

深克隆与浅克隆

什么是深克隆与浅克隆呢?

在Java语言中,数据类型分为值类型(基本数据类型)和引用类型,值类型包括int、double、byte、boolean、char等简单数据类型,引用类型包括类、接口、数组等复杂类型,浅克隆和深克隆的主要区别在于是否支持引用类型的成员变量的复制。

浅克隆

在浅克隆中,如果是对象的值类型成员变量,直接复制一份。如果是对象的引用类型成员变量,则仅仅将引用对象的地址复制一份给克隆对象,简单说就是克隆对象与原对象中的引用类型成员变量指向是同一个内存地址,同一个对象。

Object中的clone()方法就是属于浅克隆,所以才会出现上面那种情况,真大圣与克隆大圣拿的是同一根金箍棒。

那怎么解决呢? 没错,我们还有深克隆 。

深克隆

通过上面关于浅克隆的介绍,相信聪明的童鞋应该想到了,所谓深克隆就是将引用类型成员变量指向的对象也克隆一份给克隆对象。

那么怎么实现深克隆呢?

在Java语言中,如果需要实现深克隆,可以通过序列化(Serialization)等方式来实现。序列化就是将对象写到流的过程,写到流中的对象是原有对象的一个克隆,而原对象仍然存在于内存中。通过序列化实现的克隆不仅可以复制对象本身,而且可以复制其引用的成员对象,因此通过序列化将对象写到一个流中,再从流里将其读出来,可以实现深克隆。需要注意的是能够实现序列化的对象其类必须实现Serializable接口,否则无法实现序列化操作。

下面我们还是以大圣的例子来演示吧

UML图

代码

修改代码如下

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
public class MonkeyKing implements Serializable {

...

public MonkeyKing(int height, int weight, int age) {
this.height = height;
this.weight = weight;
this.age = age;
goldHoopStick = new GoldHoopStick();
}

...

public MonkeyKing deepClone() {
Object object = null;
try {
//将对象写入流中
ByteArrayOutputStream bao = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bao);
oos.writeObject(this);

//将对象从流中取出
ByteArrayInputStream bis = new ByteArrayInputStream(bao.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
object = ois.readObject();
return (MonkeyKing) object;
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}

return null;
}
}
1
2
3
4
5
public class GoldHoopStick implements Serializable {

...

}

客户端代码

1
2
3
4
5
6
7
8
9
10
11
public class Client {

public static void main(String[] args) {
MonkeyKing monkeyKing = new MonkeyKing(180, 75, 500);

MonkeyKing copyMonkey = monkeyKing.deepClone();

System.out.println("是同一个大圣? " + (monkeyKing == copyMonkey));
System.out.println("是同一根棒子吗? " + (monkeyKing.getGoldHoopStick() == copyMonkey.getGoldHoopStick()));
}
}

测试结果如下

1
2
是同一个大圣? false
是同一根棒子吗? false

完美!我们成功的将大圣的棒子也克隆了一份!

登记式原型模式

其实所谓的登记式原型模式,就是引入一个原型管理类,它通过内部定义一个集合用于存储原型对象,集中管理多个原型对象。当客户端需要某个原型对象的克隆时,可以通过这个原型管理类来获得。

UML图

代码

PrototypeConcretePrototype的代码无需变动,增加PrototypeManager代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public enum PrototypeManager {
instance;

private Hashtable<String, Prototype> prototypeHashtable = new Hashtable<>();

private PrototypeManager() {
prototypeHashtable.put("CPA",new ConcretePrototypeA("attrs"));
}

public void add(String key, Prototype prototype) {
prototypeHashtable.put(key, prototype);
}

public Prototype get(String key) {
return prototypeHashtable.get(key).clone();
}
}

这里使用枚举实现单例,忘记单例模式的可以看看前面的文章。

客户端代码

1
2
3
4
5
6
7
8
9
10
11
public class Client {

public static void main(String[] args) {

Prototype prototype1 = PrototypeManager.instance.get("CPA");
Prototype prototype2 = PrototypeManager.instance.get("CPA");

System.out.println("两个对象是同一个对象? " + (prototype1 == prototype2));
System.out.println("两个对象值相等? " + prototype1.equals(prototype2));
}
}

运行结果如下

1
2
两个对象是同一个对象? false
两个对象值相等? true

这就是登记式原型模式的使用

小结

当创建新的对象比较复杂或者耗时太长,而新建对象又与已有对象相似时,可以使用原型模式,通过复制创建一个新对象,提高创建效率。比较复杂的是实现克隆需要对每一个具体原型重写克隆方法,当存在引入类型成员变量时,还需要使用深克隆来实现完全克隆。

你喜欢 Ctrl+CCtrl+V吗? 那你一定会喜欢原型模式的😄。


源码:https://github.com/lichenming0516/DesignPattern

坚持原创技术分享,您的支持将鼓励我继续创作!