1 原型模式介绍
原型模式(Prototype)是一个创建型的模式，原型模式是有一个共有信息的样板实例，然后拷贝这个样板实例，而复制后的实例就是所谓的“原型”，这个原型是可以修改的。原型模式多用于创建复杂的或者构造耗时的实例，因为这种情况下， 复制一个已经存在的实例可以使程序运行更高效。
2 原型模式定义
用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象
3 原型模式UML类图
在原型模式中有如下角色：
-
Client：客户端角色。 -
Prototype：抽象原型角色，抽象类或者接口，用来声明clone方法。 -
ConcretePrototype：具体的原型类，是客户端角色使用的对象，即被复制的对象。
4 原型模式的使用场景
- 类初始化需要消耗非常多的资源，这个资源包括数据、硬件资源等。通过原型拷贝避免这些消耗。
- 通过
new产生一个独享需要非常频繁的数据准备或访问权限。 - 一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用，即保护性拷贝。
5 原型模式使用示例
下面我们模拟一个发送短信的例子，来看下原型模式的简单使用:
其中Message类扮演的是ConcretePrototype，Cloneable就是Prototype
具体的原型类：
public class Message implements Cloneable{
private String name;
private double money;
public Message() {
System.out.println("执行构造函数Message");
}
public void setMessage(String name, double money) {
this.name = name;
this.money = money;
}
@NonNull
@Override
public Message clone() {
Message message = null;
try {
message = (Message) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return message;
}
public void sendMessage(){
System.out.println(name +"您好：您今天消费了"+money+"元");
}
}
Message 类实现了Cloneable接口，它是一个标识接口，表示这个对象是可拷贝的，只要重写clone方法就可以实现拷贝。
这里需要注意的是clone方法并不是Cloneable接口中的，而是Object中的方法。
下面我们看下客户端实现：
public class MbClient {
public static void main(String[] args){
Message message = new Message();
message.setMessage("张三",100);
Message message1 = message.clone();
message1.setMessage("李四",200);
Message message2 = message.clone();
message2.setMessage("王五",300);
message.sendMessage();
message1.sendMessage();
message2.sendMessage();
}
}
我们可以看到李四和王五的消息是通过clone方法克隆的，而clone方法是不会执行构造函数的。输出的结果如下：
//执行构造函数Message
//张三您好：您今天消费了100.0元
//李四您好：您今天消费了200.0元
//王五您好：您今天消费了300.0元
如果Message 类没有实现了Cloneable接口，就去直接调用clone方法，就会抛出异常。输出结果如下：
执行构造函数Message
java.lang.CloneNotSupportedException: com.monkey.myapplication.mbdemo.Message
at java.lang.Object.clone(Native Method)
at com.monkey.myapplication.mbdemo.Message.clone(Message.java:27)
at com.monkey.myapplication.mbdemo.MbClient.main(MbClient.java:13)
Exception in thread "main" java.lang.NullPointerException
at com.monkey.myapplication.mbdemo.MbClient.main(MbClient.java:14)
6 浅拷贝和深拷贝
由于Object类提供的clone方法，不会拷贝对象中的内部数组和引用对象，所以就有了浅拷贝和深拷贝。
6.1 浅拷贝
我们继续使用发送短信的例子来看下浅拷贝，在Message类中有一个消费明细对象。
public class Message implements Cloneable{
private String name; //姓名
private ExpenseDetail detail;//消费明细
public Message() {
System.out.println("执行构造函数Message");
detail = new ExpenseDetail();
}
public void setMessage(String name, String type,double money) {
this.name = name;
this.detail.setType(type);
this.detail.setMoney(money);
}
@NonNull
@Override
public Message clone() {
Message message = null;
try {
message = (Message) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return message;
}
public void sendMessage(){
System.out.println(name +"您好：您今天"+detail.getType()+"消费了"+detail.getMoney()+"元");
}
}
消费明细类
public class ExpenseDetail{
private String type;
private double money;
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public double getMoney() {
return money;
}
public void setMoney(double money) {
this.money = money;
}
}
客户端类
public class MbClient {
public static void main(String[] args){
Message message = new Message();
message.setMessage("张三","吃饭",10);
Message message1 = message.clone();
message1.setMessage("李四","看电影",50);
Message message2 = message.clone();
message2.setMessage("王五","买书",100);
message.sendMessage();
message1.sendMessage();
message2.sendMessage();
}
}
输出的结果如下：
执行构造函数Message
张三您好：您今天买书消费了100.0元
李四您好：您今天买书消费了100.0元
王五您好：您今天买书消费了100.0元
我们可以看到所有人的消费明细居然都一样，这是因为Object类提供的clone方法，不会拷贝对象中的内部数组和引用对象，导致它们仍旧指向原来对象的内部元素地址，这种拷贝叫做浅拷贝。
由此而导致最后一次的值会覆盖前一次的值。
6.2 深拷贝
public class Message implements Cloneable{
...
@NonNull
@Override
public Message clone() {
Message message = null;
try {
message = (Message) super.clone();
message.detail = this.detail.clone();//拷贝消费明细
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return message;
}
...
}
public class ExpenseDetail implements Cloneable{
private String type;
private double money;
...
@NonNull
@Override
protected ExpenseDetail clone(){
ExpenseDetail detail = null;
try {
detail = (ExpenseDetail) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return detail;
}
}
使用浅拷贝的客户端代码再次执行后，输出的结果如下：
执行构造函数Message
张三您好：您今天吃饭消费了10.0元
李四您好：您今天看电影消费了50.0元
王五您好：您今天买书消费了100.0元
拷贝Message对象的同时，也将它内部的引用对象ExpenseDetail进行拷贝，使得每个拷贝的对象之间无任何关联，都指向了自身对应的ExpenseDetail，这种拷贝就是深拷贝。
7 总结
原型模式本质上就是对象拷贝。使用原型模式可以解决构建复杂对象的资源消耗问题，能够在某些场景下提升创建对象的效率，还有一个特点就是保护性拷贝，如果我们操作时，不会对原有的对象造成影响。
优点：
原型模式是在内存中二进制流的拷贝，要比new一个对象的性能要好，特别是需要生产大量对象时。
缺点：
直接在内存中拷贝，构造函数是不会执行的，这样就减少了约束，既是优点也是缺点，在实际开发当中应注意这个问题。