【白话设计模式十二】原型模式(Prototype)
#0 系列目录#java
- 白话设计模式
- 工厂模式
- 单例模式
- 【白话设计模式一】简单工厂模式(Simple Factory)
- 【白话设计模式二】外观模式(Facade)
- 【白话设计模式三】适配器模式(Adapter)
- 【白话设计模式四】单例模式(Singleton)
- 【白话设计模式五】工厂方法模式(Factory Method)
- 【白话设计模式六】抽象工厂模式(Abstract Factory)
- 【白话设计模式七】策略模式(Strategy)
- 【白话设计模式八】命令模式(Command)
- 【白话设计模式九】桥接模式(Bridge)
- 【白话设计模式十】装饰模式(Decorator)
- 【白话设计模式十一】生成器模式(Builder)
- 【白话设计模式十二】原型模式(Prototype)
- 【白话设计模式十三】中介者模式(Mediator)
- 【白话设计模式十四】代理模式(Proxy)
- 【白话设计模式十五】观察者模式(Observer)
- 【白话设计模式十六】迭代器模式(Iterator)
- 【白话设计模式十七】组合模式(Composite)
- 【白话设计模式十八】模板方法模式(Template Method)
- 【白话设计模式十九】状态模式(State)
- 【白话设计模式二十】备忘录模式(Memento)
- 【白话设计模式二十一】享元模式(Flyweight)
- 【白话设计模式二十二】解释器模式(Interpreter)
- 【白话设计模式二十三】职责链模式(Chain of Responsibility)
- 【白话设计模式二十四】访问者模式(Visitor)
- 【白话设计模式二十五】临别总结：设计模式与7大原则
#1 场景问题# ##1.1 订单处理系统## 考虑这样一个实际应用：订单处理系统。算法
如今有一个订单处理的系统，里面有个保存订单的业务功能，在这个业务功能里面，客户有这么一个需求：每当订单的预约产品数量超过1000的时候，就须要把订单拆成两份订单来保存，若是拆成两份订单后，仍是超过1000，那就继续拆分，直到每份订单的预约产品数量不超过1000。至于为何要拆分，缘由是好进行订单的后续处理，后续是由人工来处理，每一个人工工做小组的处理能力上限是1000。编程
根据业务，目前的订单类型被分红两种：一种是我的订单，一种是公司订单。如今想要实现一个通用的订单处理系统，也就是说，无论具体是什么类型的订单，都要可以正常的处理。设计模式
该怎么实现呢？缓存
##1.2 不用模式的解决方案## 来分析上面要求实现的功能，有朋友会想，这很简单嘛，一共就一个功能，没什么困难的，真的是这样吗？先来尝试着实现看看。多线程
- 定义订单接口
首先，要想实现通用的订单处理，而不关心具体的订单类型，那么很明显，订单处理的对象应该面向一个订单的接口或是一个通用的订单对象来编程，这里就选用面向订单接口来处理吧，先把这个订单接口定义出来，示例代码以下：工具
/**
* 订单的接口
*/
public interface OrderApi {
/**
* 获取订单产品数量
* @return 订单中产品数量
*/
public int getOrderProductNum();
/**
* 设置订单产品数量
* @param num 订单产品数量
*/
public void setOrderProductNum(int num);
}
- 既然定义好了订单的接口，那么接下来把各类类型的订单实现出来，先看看我的的订单实现，示例代码以下：
/**
* 我的订单对象
*/
public class PersonalOrder implements OrderApi{
/**
* 订购人员姓名
*/
private String customerName;
/**
* 产品编号
*/
private String productId;
/**
* 订单产品数量
*/
private int orderProductNum = 0;
public int getOrderProductNum() {
return this.orderProductNum;
}
public void setOrderProductNum(int num) {
this.orderProductNum = num;
}
public String getCustomerName() {
return customerName;
}
public void setCustomerName(String customerName) {
this.customerName = customerName;
}
public String getProductId() {
return productId;
}
public void setProductId(String productId) {
this.productId = productId;
}
public String toString(){
return "本我的订单的订购人是="+this.customerName+"，订购产品是="+this.productId+"，订购数量为="+this.orderProductNum;
}
}
再看看企业订单的实现，示例代码以下：学习
/**
* 企业订单对象
*/
public class EnterpriseOrder implements OrderApi{
/**
* 企业名称
*/
private String enterpriseName;
/**
* 产品编号
*/
private String productId;
/**
* 订单产品数量
*/
private int orderProductNum = 0;
public int getOrderProductNum() {
return this.orderProductNum;
}
public void setOrderProductNum(int num) {
this.orderProductNum = num;
}
public String getEnterpriseName() {
return enterpriseName;
}
public void setEnterpriseName(String enterpriseName) {
this.enterpriseName = enterpriseName;
}
public String getProductId() {
return productId;
}
public void setProductId(String productId) {
this.productId = productId;
}
public String toString(){
return "本企业订单的订购企业是="+this.enterpriseName+"，订购产品是="+this.productId+"，订购数量为="+this.orderProductNum;
}
}
有些朋友看到这里，可能会有这样的疑问：看上去上面两种类型的订单对象，仅仅是一个数据封装的对象，并且还有一些数据是相同的，为什么不抽出一个父类来，把共同的数据定义在父类里面呢？测试
这里有两个考虑，一个是：这里仅仅是一个示意，实际状况远比这复杂，实际开发中不会仅仅是数据封装对象这么简单。另一个是：为了后续示例的重点突出，这里要学习的是原型模式，所以就没有去抽取父类，以避免对象层级过多，影响主题的展现。ui
- 实现好了订单对象，接下来看看如何实现通用的订单处理，先把订单处理的对象大概定义出来，示例代码以下：
/**
* 处理订单的业务对象
*/
public class OrderBusiness {
/**
* 建立订单的方法
* @param order 订单的接口对象
*/
public void saveOrder(OrderApi order){
//等待具体实现
}
}
如今的中心任务就是要来实现这个saveOrder的方法，传入的参数是一个订单的接口对象，这个方法要实现的功能：根据业务要求，当订单的预约产品数量超过1000的时候，就须要把订单拆成两份订单。
那好，来尝试着实现一下，由于预约的数量可能会很大，所以采用一个while循环来处理，直到拆分后订单的数量不超过1000，先把实现的思路写出来，示例代码以下：
public class OrderBusiness {
public void saveOrder(OrderApi order){
//1：判断当前的预约产品数量是否大于1000
while(order.getOrderProductNum() > 1000){
//2：若是大于，还须要继续拆分
//2.1再新建一份订单，跟传入的订单除了数量不同外，其它都相同
OrderApi newOrder = null;
...
}
}
}
你们会发现，才刚写到第二步就写不下去了，为何呢？由于如今判断须要拆分订单，也就是须要新建一个订单对象，但是订单处理对象面对的是订单的接口，它根本就不知道如今订单具体的类型，也不知道具体的订单实现，它没法建立出新的订单对象来，也就没法实现订单拆分的功能了。
- 一个简单的解决办法
有朋友提供了这么一个解决的思路，他说：不就是在saveOrder方法里面不知道具体的类型，从而致使没法建立对象吗？很简单，使用instanceof来判断不就能够了，他还给出了他的实现示意，示意代码以下：
public class OrderBusiness {
public void saveOrder(OrderApi order){
while(order.getOrderProductNum() > 1000)
//定义一个表示被拆分出来的新订单对象
OrderApi newOrder = null;
if(order instanceof PersonalOrder){
//建立相应的订单对象
PersonalOrder p2 = new PersonalOrder();
//而后进行赋值等，省略了
//而后再设置给newOrder
newOrder = p2;
}else if(order instanceof EnterpriseOrder){
//建立相应的订单对象
EnterpriseOrder e2 = new EnterpriseOrder();
//而后进行赋值等，省略了
//而后再设置给newOrder
newOrder = e2;
}
//而后进行拆分和其它业务功能处理，省略了
}
}
}
好像能解决问题，对吧。那咱们就来按照他提供的思路，把这个通用的订单处理对象实现出来，示例代码以下：
/**
* 处理订单的业务对象
*/
public class OrderBusiness {
/**
* 建立订单的方法
* @param order 订单的接口对象
*/
public void saveOrder(OrderApi order){
//根据业务要求，当订单预约产品数量超过1000时，就要把订单拆成两份订单
//固然若是要作好，这里的1000应该作成常量，这么作是为了演示简单
//1：判断当前的预约产品数量是否大于1000
while(order.getOrderProductNum() > 1000){
//2：若是大于，还须要继续拆分
//2.1再新建一份订单，跟传入的订单除了数量不同外，其它都相同
OrderApi newOrder = null;
if(order instanceof PersonalOrder){
//建立相应的新的订单对象
PersonalOrder p2 = new PersonalOrder();
//而后进行赋值，可是产品数量为1000
PersonalOrder p1 = (PersonalOrder)order;
p2.setCustomerName(p1.getCustomerName());
p2.setProductId(p1.getProductId());
p2.setOrderProductNum(1000);
//而后再设置给newOrder
newOrder = p2;
}else if(order instanceof EnterpriseOrder){
//建立相应的订单对象
EnterpriseOrder e2 = new EnterpriseOrder();
//而后进行赋值，可是产品数量为1000
EnterpriseOrder e1 = (EnterpriseOrder)order;
e2.setEnterpriseName(e1.getEnterpriseName());
e2.setProductId(e1.getProductId());
e2.setOrderProductNum(1000);
//而后再设置给newOrder
newOrder = e2;
}
//2.2原来的订单保留，把数量设置成减小1000
order.setOrderProductNum(order.getOrderProductNum()-1000);
//而后是业务功能处理，省略了，打印输出，看一下
System.out.println("拆分生成订单=="+newOrder);
}
//3：不超过1000，那就直接业务功能处理，省略了，打印输出，看一下
System.out.println("订单=="+order);
}
}
- 写个客户端来测试一下，示例代码以下：
public class OrderClient {
public static void main(String[] args) {
//建立订单对象，这里为了演示简单，直接new了
PersonalOrder op = new PersonalOrder();
//设置订单数据
op.setOrderProductNum(2925);
op.setCustomerName("张三");
op.setProductId("P0001");
//这里获取业务处理的类，也直接new了，为了简单，连业务接口都没有作
OrderBusiness ob = new OrderBusiness();
//调用业务来保存订单对象
ob.saveOrder(op);
}
}
运行结果以下：
拆分生成订单==本我的订单的订购人是=张三，订购产品是=P0001，订购数量为=1000 拆分生成订单==本我的订单的订购人是=张三，订购产品是=P0001，订购数量为=1000 订单==本我的订单的订购人是=张三，订购产品是=P0001，订购数量为=925
根据订单中订购产品的数量，一份订单被拆分红了三份。一样的，你还能够传入企业订单，看看是否能正常知足功能要求。
##1.3 有何问题## 看起来，上面的实现确实不难，好像也可以通用的进行订单处理，而不须要关心订单的类型和具体实现这样的功能。
仔细想一想，真的没有关心订单的类型和具体实现吗？答案是“否认的”。
事实上，在实现订单处理的时候，上面的实现是按照订单的类型和具体实现来处理的，就是instanceof的那一段。有朋友可能会问，这样实现有何不可吗？这样的实现有以下几个问题：
既然想要实现通用的订单处理，那么对于订单处理的实现对象，是不该该知道订单的具体实现的，更不该该依赖订单的具体实现。可是上面的实现中，很明显订单处理的对象依赖了订单的具体实现对象。这种实现方式另一个问题就是：
难以扩展新的订单类型。假如如今要加入一个大客户专用订单的类型，那么就须要修改订单处理的对象，要在里面添加对新的订单类型的支持，这算哪门子的通用处理。
所以，上面的实现是不太好的，把上面的问题再抽象描述一下：已经有了某个对象实例后，如何可以快速简单地建立出更多的这种对象？好比上面的问题，就是已经有了订单接口类型的对象实例，而后在方法中须要建立出更多的这种对象。怎么解决呢？
#2 解决方案# ##2.1 原型模式来解决## 用来解决上述问题的一个合理的解决方案就是原型模式。那么什么是原型模式呢？
- 原型模式定义
- 应用原型模式来解决的思路
仔细分析上面的问题，在saveOrder方法里面，已经有了订单接口类型的对象实例，是从外部传入的，可是这里只是知道这个实例对象的种类是订单的接口类型，并不知道其具体的实现类型，也就是不知道它究竟是我的订单仍是企业订单，可是如今须要在这个方法里面建立一个这样的订单对象，看起来就像是要经过接口来建立对象同样。
原型模式就能够解决这样的问题，原型模式会要求对象实现一个能够“克隆”自身的接口，这样就能够经过拷贝或者是克隆一个实例对象自己，来建立一个新的实例。若是把这个方法定义在接口上，看起来就像是经过接口来建立了新的接口对象。
这样一来，经过原型实例建立新的对象，就再也不须要关心这个实例自己的类型，也不关心它的具体实现，只要它实现了克隆自身的方法，就能够经过这个方法来获取新的对象，而无须再去经过new来建立。
##2.2 模式结构和说明##
Prototype：声明一个克隆自身的接口，用来约束想要克隆本身的类，要求它们都要实现这里定义的克隆方法。
ConcretePrototype：实现Prototype接口的类，这些类真正实现了克隆自身的功能。
Client：使用原型的客户端，首先要获取到原型实例对象，而后经过原型实例克隆自身来建立新的对象实例。
##2.3 原型模式示例代码##
- 先来看看原型接口的定义，示例代码以下：
/**
* 声明一个克隆自身的接口
*/
public interface Prototype {
/**
* 克隆自身的方法
* @return 一个从自身克隆出来的对象
*/
public Prototype clone();
}
- 接下来看看具体的原型实现对象，示例代码以下：
/**
* 克隆的具体实现对象
*/
public class ConcretePrototype1 implements Prototype {
public Prototype clone() {
//最简单的克隆，新建一个自身对象，因为没有属性，就不去复制值了
Prototype prototype = new ConcretePrototype1();
return prototype;
}
}
/**
* 克隆的具体实现对象
*/
public class ConcretePrototype2 implements Prototype {
public Prototype clone() {
//最简单的克隆，新建一个自身对象，因为没有属性，就不去复制值了
Prototype prototype = new ConcretePrototype2();
return prototype;
}
}
为了跟上面原型模式的结构示意图保持一致，所以这两个具体的原型实现对象，都没有定义属性。事实上，在实际使用原型模式的应用中，原型对象可能是有属性的，克隆原型的时候也是须要克隆原型对象的属性的，特此说明一下。
- 再看看使用原型的客户端，示例代码以下：
/**
* 使用原型的客户端
*/
public class Client {
/**
* 持有须要使用的原型接口对象
*/
private Prototype prototype;
/**
* 构造方法，传入须要使用的原型接口对象
* @param prototype 须要使用的原型接口对象
*/
public Client(Prototype prototype){
this.prototype = prototype;
}
/**
* 示意方法，执行某个功能操做
*/
public void operation(){
//会须要建立原型接口的对象
Prototype newPrototype = prototype.clone();
}
}
##2.4 使用原型模式重写示例## 要使用原型模式来重写示例，先要在订单的接口上定义出克隆的接口，而后要求各个具体的订单对象克隆自身，这样就能够解决：在订单处理对象里面经过订单接口来建立新的订单对象的问题。
使用原型模式来重写示例的结构如图9.2所示：
- 复制谁和谁来复制的问题
有了一个对象实例，要快速的建立跟它同样的实例，最简单的办法就是复制？这里又有两个小的问题：
复制谁呢？固然是复制这个对象实例，复制实例的意思是连带着数据一块儿复制。
谁来复制呢？应该让这个类的实例本身来复制，本身复制本身。
但是每一个对象不会那么听话，本身去实现复制本身的。因而原型模式决定对这些对象实行强制要求，给这些对象定义一个接口，在接口里面定义一个方法，这个方法用来要求每一个对象实现本身复制本身。
因为如今存在订单的接口，所以就把这个要求克隆自身的方法定义在订单的接口里面，示例代码以下：
/**
* 订单的接口，声明了能够克隆自身的方法
*/
public interface OrderApi {
public int getOrderProductNum();
public void setOrderProductNum(int num);
/**
* 克隆方法
* @return 订单原型的实例
*/
public OrderApi cloneOrder();
}
- 如何克隆
定义好了克隆的接口，那么在订单的实现类里面，就得让它实现这个接口，并具体的实现这个克隆方法，新的问题出来了，如何实现克隆呢？
很简单，只要先new一个本身对象的实例，而后把本身实例中的数据取出来，设置到新的对象实例中去，不就能够完成实例的复制了嘛，复制的结果就是有了一个跟自身如出一辙的实例。
/**
* 我的订单对象
*/
public class PersonalOrder implements OrderApi{
private String customerName;
private String productId;
private int orderProductNum = 0;
public int getOrderProductNum() {
return this.orderProductNum;
}
public void setOrderProductNum(int num) {
this.orderProductNum = num;
}
public String getCustomerName() {
return customerName;
}
public void setCustomerName(String customerName) {
this.customerName = customerName;
}
public String getProductId() {
return productId;
}
public void setProductId(String productId) {
this.productId = productId;
}
public String toString(){
return "本我的订单的订购人是="+this.customerName+"，订购产品是="+this.productId+"，订购数量为="+this.orderProductNum;
}
public OrderApi cloneOrder() {
//建立一个新的订单，而后把本实例的数据复制过去
PersonalOrder order = new PersonalOrder();
order.setCustomerName(this.customerName);
order.setProductId(this.productId);
order.setOrderProductNum(this.orderProductNum);
return order;
}
}
接下来看看企业订单的具体实现，示例代码以下：
/**
* 企业订单对象
*/
public class EnterpriseOrder implements OrderApi{
private String enterpriseName;
private String productId;
private int orderProductNum = 0;
public int getOrderProductNum() {
return this.orderProductNum;
}
public void setOrderProductNum(int num) {
this.orderProductNum = num;
}
public String getEnterpriseName() {
return enterpriseName;
}
public void setEnterpriseName(String enterpriseName) {
this.enterpriseName = enterpriseName;
}
public String getProductId() {
return productId;
}
public void setProductId(String productId) {
this.productId = productId;
}
public String toString(){
return "本企业订单的订购企业是="+this.enterpriseName+"，订购产品是="+this.productId+"，订购数量为="+this.orderProductNum;
}
public OrderApi cloneOrder() {
//建立一个新的订单，而后把本实例的数据复制过去
EnterpriseOrder order = new EnterpriseOrder();
order.setEnterpriseName(this.enterpriseName);
order.setProductId(this.productId);
order.setOrderProductNum(this.orderProductNum);
return order;
}
}
- 使用克隆方法
这里使用订单接口的克隆方法的，是订单的处理对象，也就是说，订单的处理对象就至关于原型模式结构中的Client。
固然，客户端在调用clone方法以前，还须要先得到相应的实例对象，有了实例对象，才能调用该实例对象的clone方法。
这里使用克隆方法的时候，跟标准的原型实现有一些不一样，在标准的原型实现的示例代码里面，客户端是持有须要克隆的对象，而这里变化成了经过方法传入须要使用克隆的对象，这点你们注意一下。示例代码以下：
public class OrderBusiness {
/**
* 建立订单的方法
* @param order 订单的接口对象
*/
public void saveOrder(OrderApi order){
//1：判断当前的预约产品数量是否大于1000
while(order.getOrderProductNum() > 1000){
//2：若是大于，还须要继续拆分
//2.1再新建一份订单，跟传入的订单除了数量不同外，其它都相同
OrderApi newOrder = order.cloneOrder();
//而后进行赋值，产品数量为1000
newOrder.setOrderProductNum(1000);
//2.2原来的订单保留，把数量设置成减小1000
order.setOrderProductNum(order.getOrderProductNum()-1000);
//而后是业务功能处理，省略了，打印输出，看一下
System.out.println("拆分生成订单=="+newOrder);
}
//3：不超过，那就直接业务功能处理，省略了，打印输出，看一下
System.out.println("订单=="+order);
}
}
##2.5 小提示## 看到这里，可能有些朋友会认为：Java的Object里面自己就有clone方法，还用搞得这么麻烦吗？
虽然Java里面有clone方法，上面这么作仍是颇有意义的，可让咱们更好的、更完整的体会原型这个设计模式。固然，后面会讲述如何使用Java里面的clone方法来实现克隆，不要着急。
#3 模式讲解# ##3.1 认识原型模式##
- 原型模式的功能
原型模式的功能实际上包含两个方面：
一个是经过克隆来建立新的对象实例；
另外一个是为克隆出来的新的对象实例复制原型实例属性的值；
原型模式要实现的主要功能就是：经过克隆来建立新的对象实例。通常来说，新建立出来的实例的数据是和原型实例同样的。可是具体如何实现克隆，须要由程序自行实现，原型模式并无统一的要求和实现算法。
- 原型与new
原型模式从某种意义上说，就像是new操做，在前面的例子实现中，克隆方法就是使用new来实现的，但请注意，只是“相似于new”而不是“就是new”。
克隆方法和new操做最明显的不一样就在于：new一个对象实例，通常属性是没有值的，或者是只有默认值；若是是克隆获得的一个实例，一般属性是有值的，属性的值就是原型对象实例在克隆的时候，原型对象实例的属性的值。
- 原型实例和克隆的实例
原型实例和克隆出来的实例，本质上是不一样的实例，克隆完成后，它们之间是没有关联的，若是克隆完成后，克隆出来的实例的属性的值发生了改变，是不会影响到原型实例的。下面写个示例来测试一下，示例代码以下：
public class Client {
public static void main(String[] args) {
//先建立原型实例
OrderApi oa1 = new PersonalOrder();
//设置原型实例的订单数量的值
oa1.setOrderProductNum(100);
//为了简单，这里仅仅输出数量
System.out.println("这是第一次获取的对象实例==="+oa1.getOrderProductNum());
//经过克隆来获取新的实例
OrderApi oa2 = (OrderApi)oa1.cloneOrder();
//修改它的数量
oa2.setOrderProductNum(80);
//输出克隆出来的对象的值
System.out.println("输出克隆出来的实例==="+oa2.getOrderProductNum());
//再次输出原型实例的值
System.out.println("再次输出原型实例==="+oa1.getOrderProductNum());
}
}
运行一下，看看结果：
这是第一次获取的对象实例===100 输出克隆出来的实例===80 再次输出原型实例===100
仔细观察上面的结果，会发现原型实例和克隆出来的实例是彻底独立的，也就是它们指向不一样的内存空间。由于克隆出来的实例的值已经被改变了，而原型实例的值仍是原来的值，并无变化，这就说明两个实例是对应的不一样内存空间。
- 原型模式的调用顺序示意图
##3.2 Java中的克隆方法## 在Java语言中已经提供了clone方法，定义在Object类中。关于Java中clone方法的知识，这里不去赘述，下面看看怎么使用Java里面的克隆方法来实现原型模式。
须要克隆功能的类，只须要实现java.lang.Cloneable接口，这个接口没有须要实现的方法，是一个标识接口。所以在前面的实现中，把订单接口中的克隆方法去掉，如今直接实现Java中的接口就行了。新的订单接口实现，示例代码以下：
public interface OrderApi {
public int getOrderProductNum();
public void setOrderProductNum(int num);
// public OrderApi cloneOrder();
}
另外在具体的订单实现对象里面，实现方式上会有一些改变，我的订单和企业订单的克隆实现是相似的，所以示范一个就行了，看看我的订单的实现吧，示例代码以下：
/**
* 我的订单对象,利用Java的Clone功能
*/
public class PersonalOrder implements Cloneable , OrderApi {
private String customerName;
private String productId;
private int orderProductNum = 0;
public int getOrderProductNum() {
return this.orderProductNum;
}
public void setOrderProductNum(int num) {
this.orderProductNum = num;
}
public String getCustomerName() {
return customerName;
}
public void setCustomerName(String customerName) {
this.customerName = customerName;
}
public String getProductId() {
return productId;
}
public void setProductId(String productId) {
this.productId = productId;
}
public String toString(){
return "本我的订单的订购人是="+this.customerName+"，订购产品是="+this.productId+"，订购数量为="+this.orderProductNum;
}
// public OrderApi cloneOrder() {
// 建立一个新的订单，而后把本实例的数据复制过去
// PersonalOrder order = new PersonalOrder();
// order.setCustomerName(this.customerName);
// order.setProductId(this.productId);
// order.setOrderProductNum(this.orderProductNum);
// return order;
// }
public Object clone(){
//克隆方法的真正实现，直接调用父类的克隆方法就能够了
Object obj = null;
try {
obj = super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return obj;
}
}
看起来，比彻底由本身实现原型模式要稍稍简单点，是否好用呢？仍是测试一下，看看效果。客户端跟上一个示例相比，做了两点修改：
一个是原来的“OrderApi oa1 = new PersonalOrder();”这句话，要修改为：“PersonalOrder oa1 = new PersonalOrder();”。缘由是如今的接口上并无克隆的方法，所以须要修改为原型的类型；
另一个是“经过克隆来获取新的实例”的实现，须要修改为使用原型来调用在Object里面定义的clone()方法了，再也不是调用原来的cloneOrder()了。
看看测试用的代码，示例代码以下：
public class Client {
public static void main(String[] args) {
//先建立原型实例
PersonalOrder oa1 = new PersonalOrder();
//设置原型实例的订单数量的值
oa1.setOrderProductNum(100);
System.out.println("这是第一次获取的对象实例==="+oa1.getOrderProductNum());
//经过克隆来获取新的实例
PersonalOrder oa2 = (PersonalOrder)oa1.clone();
oa2.setOrderProductNum(80);
System.out.println("输出克隆出来的实例==="+oa2.getOrderProductNum());
//再次输出原型实例的值
System.out.println("再次输出原型实例==="+oa1.getOrderProductNum());
}
}
##3.3 浅度克隆和深度克隆## 不管你是本身实现克隆方法，仍是采用Java提供的克隆方法，都存在一个浅度克隆和深度克隆的问题，那么什么是浅度克隆？什么是深度克隆呢？简单地解释一下：
浅度克隆：只负责克隆按值传递的数据（好比：基本数据类型、String类型）
深度克隆：除了浅度克隆要克隆的值外，还负责克隆引用类型的数据，基本上就是被克隆实例全部的属性的数据都会被克隆出来。
深度克隆还有一个特色，若是被克隆的对象里面的属性数据是引用类型，也就是属性的类型也是对象，那么须要一直递归的克隆下去。这也意味着，要想深度克隆成功，必需要整个克隆所涉及的对象都要正确实现克隆方法，若是其中有一个没有正确实现克隆，那么就会致使克隆失败。
在前面的例子中实现的克隆就是典型的浅度克隆，下面就来看看如何实现深度克隆。
- 本身实现原型的深度克隆
（1）要演示深度克隆，须要给订单对象添加一个引用类型的属性，这样实现克隆事后，才能看出深度克隆的效果来。
那就定义一个产品对象，也须要让它实现克隆的功能，产品对象实现的是一个浅度克隆。先来定义产品的原型接口，示例代码以下：
/**
* 声明一个克隆产品自身的接口
*/
public interface ProductPrototype {
/**
* 克隆产品自身的方法
* @return 一个从自身克隆出来的产品对象
*/
public ProductPrototype cloneProduct();
}
接下来看看具体的产品对象实现，示例代码以下：
/**
* 产品对象
*/
public class Product implements ProductPrototype{
/**
* 产品编号
*/
private String productId;
/**
* 产品名称
*/
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getProductId() {
return productId;
}
public void setProductId(String productId) {
this.productId = productId;
}
public String toString(){
return "产品编号="+this.productId+"，产品名称="+this.name;
}
public ProductPrototype cloneProduct() {
//建立一个新的订单，而后把本实例的数据复制过去
Product product = new Product();
product.setProductId(this.productId);
product.setName(this.name);
return product;
}
}
（2）订单的具体实现上也须要改变一下，须要在其属性上添加一个产品类型的属性，而后也须要实现克隆方法，示例代码以下：
public class PersonalOrder implements OrderApi{
private String customerName;
private int orderProductNum = 0;
/**
* 产品对象
*/
private Product product = null;
public int getOrderProductNum() {
return this.orderProductNum;
}
public void setOrderProductNum(int num) {
this.orderProductNum = num;
}
public String getCustomerName() {
return customerName;
}
public void setCustomerName(String customerName) {
this.customerName = customerName;
}
public Product getProduct() {
return product;
}
public void setProduct(Product product) {
this.product = product;
}
public String toString(){
//简单点输出
return "订购产品是="+this.product.getName()+"，订购数量为="+this.orderProductNum;
}
public OrderApi cloneOrder() {
//建立一个新的订单，而后把本实例的数据复制过去
PersonalOrder order = new PersonalOrder();
order.setCustomerName(this.customerName);
order.setOrderProductNum(this.orderProductNum);
//对于对象类型的数据，深度克隆的时候须要继续调用这个对象的克隆方法
order.setProduct((Product)this.product.cloneProduct());
return order;
}
}
（3）写个客户端来测试看看，是否深度克隆成功，示例代码以下：
public class Client {
public static void main(String[] args) {
//先建立原型实例
PersonalOrder oa1 = new PersonalOrder();
//设置原型实例的值
Product product = new Product();
product.setName("产品1");
oa1.setProduct(product);
oa1.setOrderProductNum(100);
System.out.println("这是第一次获取的对象实例="+oa1);
//经过克隆来获取新的实例
PersonalOrder oa2 = (PersonalOrder)oa1.cloneOrder();
//修改它的值
oa2.getProduct().setName("产品2");
oa2.setOrderProductNum(80);
//输出克隆出来的对象的值
System.out.println("输出克隆出来的实例="+oa2);
//再次输出原型实例的值
System.out.println("再次输出原型实例="+oa1);
}
}
（4）运行结果以下，很明显，咱们本身作的深度克隆是成功的：
这是第一次获取的对象实例=订购产品是=产品1，订购数量为=100 输出克隆出来的实例=订购产品是=产品2，订购数量为=80 再次输出原型实例=订购产品是=产品1，订购数量为=100
（5）小结
看来本身实现深度克隆也不是很复杂，可是比较麻烦，若是产品类里面又有属性是引用类型的话，在产品类实现克隆方法的时候，又须要调用那个引用类型的克隆方法了，这样一层一层调下去，若是中途有任何一个对象没有正确实现深度克隆，那将会引发错误，这也是深度克隆容易出错的缘由。
- Java中的深度克隆
（1）产品类没有太大的不一样，主要是把实现的接口变成了Cloneable，这样一来，实现克隆的方法就不是cloneProduct，而是变成clone方法了；另一个是克隆方法的实现变成了使用“super.clone();”了，示例代码以下：
public class Product implements Cloneable{
private String productId;
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getProductId() {
return productId;
}
public void setProductId(String productId) {
this.productId = productId;
}
public String toString(){
return "产品编号="+this.productId+"，产品名称="+this.name;
}
public Object clone() {
Object obj = null;
try {
obj = super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return obj;
}
}
（2）具体的订单实现类，除了改变接口外，更重要的是在实现clone方法的时候，除了调用“super.clone();”外，必须显示的调用引用类型属性的clone方法，也就是产品的clone方法，示例代码以下：
public class PersonalOrder implements Cloneable , OrderApi{
private String customerName;
private Product product = null;
private int orderProductNum = 0;
public int getOrderProductNum() {
return this.orderProductNum;
}
public void setOrderProductNum(int num) {
this.orderProductNum = num;
}
public String getCustomerName() {
return customerName;
}
public void setCustomerName(String customerName) {
this.customerName = customerName;
}
public Product getProduct() {
return product;
}
public void setProduct(Product product) {
this.product = product;
}
public String toString(){
//简单点输出
return "订购产品是="+this.product.getName()+"，订购数量为="+this.orderProductNum;
}
public Object clone(){
PersonalOrder obj=null;
try {
obj =(PersonalOrder)super.clone();
//下面这一句话不可少
obj.setProduct((Product)this.product.clone());
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return obj;
}
}
（3）特别强调：不可缺乏“obj.setProduct((Product)this.product.clone());”这句话。为何呢？
缘由在于调用super.clone()方法的时候，Java是先开辟一块内存的空间，而后把实例对象的值原样拷贝过去，对于基本数据类型这样作是没有问题的，而属性product是一个引用类型，把值拷贝过去的意思就是把对应的内存地址拷贝过去了，也就是说克隆后的对象实例的product和原型对象实例的product指向的是同一块内存空间，是同一个产品实例。
所以要想正确的执行深度拷贝，必须手工的对每个引用类型的属性进行克隆，并从新设置，覆盖掉super.clone()所拷贝的值。
##3.4 原型管理器## 若是一个系统中原型的数目不固定，好比系统中的原型能够被动态的建立和销毁，那么就须要在系统中维护一个当前可用的原型的注册表，这个注册表就被称为原型管理器。
其实若是把原型当成一个资源的话，原型管理器就至关于一个资源管理器，在系统开始运行的时候初始化，而后运行期间能够动态的添加资源和销毁资源。从这个角度看，原型管理器就能够至关于一个缓存资源的实现，只不过里面缓存和管理的是原型实例而已。
有了原型管理器事后，通常状况下，除了向原型管理器里面添加原型对象的时候是经过new来创造的对象，其他时候都是经过向原型管理器来请求原型实例，而后经过克隆方法来获取新的对象实例，这就能够实现动态管理、或者动态切换具体的实现对象实例。
仍是经过示例来讲明，如何实现原型管理器。
- 先定义原型的接口，很是简单，除了克隆方法，提供一个名称的属性，示例代码以下：
public interface Prototype {
public Prototype clone();
public String getName();
public void setName(String name);
}
- 再来看看两个具体的实现，实现方式基本上是同样的，分别看看。先看第一个原型的实现，示例代码以下：
public class ConcretePrototype1 implements Prototype {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Prototype clone() {
ConcretePrototype1 prototype = new ConcretePrototype1();
prototype.setName(this.name);
return prototype;
}
public String toString(){
return "Now in Prototype1，name="+name;
}
}
再看看第二个原型的实现，示例代码以下：
public class ConcretePrototype2 implements Prototype {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Prototype clone() {
ConcretePrototype2 prototype = new ConcretePrototype2();
prototype.setName(this.name);
return prototype;
}
public String toString(){
return "Now in Prototype2，name="+name;
}
}
- 接下来看看原型管理器的实现示意，示例代码以下：
/**
* 原型管理器
*/
public class PrototypeManager {
/**
* 用来记录原型的编号和原型实例的对应关系
*/
private static Map<String,Prototype> map = new HashMap<String,Prototype>();
/**
* 私有化构造方法，避免外部无谓的建立实例
*/
private PrototypeManager(){
//
}
/**
* 向原型管理器里面添加或是修改某个原型注册
* @param prototypeId 原型编号
* @param prototype 原型实例
*/
public synchronized static void setPrototype(String prototypeId,Prototype prototype){
map.put(prototypeId, prototype);
}
/**
* 从原型管理器里面删除某个原型注册
* @param prototypeId 原型编号
*/
public synchronized static void removePrototype(String prototypeId){
map.remove(prototypeId);
}
/**
* 获取某个原型编号对应的原型实例
* @param prototypeId 原型编号
* @return 原型编号对应的原型实例
* @throws Exception 若是原型编号对应的原型实例不存在，报出例外
*/
public synchronized static Prototype getPrototype(String prototypeId)throws Exception{
Prototype prototype = map.get(prototypeId);
if(prototype == null){
throw new Exception("您但愿获取的原型尚未注册或已被销毁");
}
return prototype;
}
}
你们会发现，原型管理器是相似一个工具类的实现方式，并且对外的几个方法都是加了同步的，这主要是由于若是在多线程环境下使用这个原型管理器的话，那个map属性很明显就成了你们竞争的资源，所以须要加上同步。
- 接下来看看客户端，如何使用这个原型管理器，示例代码以下：
public class Client {
public static void main(String[] args) {
try {
// 初始化原型管理器
Prototype p1 = new ConcretePrototype1();
PrototypeManager.setPrototype("Prototype1", p1);
// 获取原型来建立对象
Prototype p3 = PrototypeManager.getPrototype("Prototype1").clone();
p3.setName("张三");
System.out.println("第一个实例：" + p3);
// 有人动态的切换了实现
Prototype p2 = new ConcretePrototype2();
PrototypeManager.setPrototype("Prototype1", p2);
// 从新获取原型来建立对象
Prototype p4 = PrototypeManager.getPrototype("Prototype1").clone();
p4.setName("李四");
System.out.println("第二个实例：" + p4);
// 有人注销了这个原型
PrototypeManager.removePrototype("Prototype1");
// 再次获取原型来建立对象
Prototype p5 = PrototypeManager.getPrototype("Prototype1").clone();
p5.setName("王五");
System.out.println("第三个实例：" + p5);
} catch (Exception err) {
System.err.println(err.getMessage());
}
}
}
运行一下，看看结果，结果示例以下：
第一个实例：Now in Prototype1，name=张三 第二个实例：Now in Prototype2，name=李四 您但愿获取的原型尚未注册或已被销毁
##3.5 原型模式的优缺点##
- 对客户端隐藏具体的实现类型
原型模式的客户端，只知道原型接口的类型，并不知道具体的实现类型，从而减小了客户端对这些具体实现类型的依赖。
- 在运行时动态改变具体的实现类型
原型模式能够在运行期间，由客户来注册符合原型接口的实现类型，也能够动态的改变具体的实现类型，看起来接口没有任何变化，但其实运行的已是另一个类实例了。由于克隆一个原型就相似于实例化一个类。
- 深度克隆方法实现会比较困难
原型模式最大的缺点就在于每一个原型的子类都必须实现clone的操做，尤为在包含引用类型的对象时，clone方法会比较麻烦，必需要可以递归的让全部的相关对象都要正确的实现克隆。
##3.6 思考原型模式##
- 原型模式的本质
原型模式的本质：克隆生成对象。
克隆是手段，目的仍是生成新的对象实例。正是由于原型的目的是为了生成新的对象实例，原型模式一般是被归类为建立型的模式。
原型模式也能够用来解决“只知接口而不知实现的问题”，使用原型模式，能够出现一种独特的“接口造接口”的景象，这在面向接口编程中颇有用。一样的功能也能够考虑使用工厂来实现。
另外，原型模式的重心仍是在建立新的对象实例，至于建立出来的对象，其属性的值是否必定要和原型对象属性的值彻底同样，这个并无强制规定，只不过在目前大多数实现中，克隆出来的对象和原型对象的属性值是同样的。
也就是说，能够经过克隆来创造值不同的实例，可是对象类型必须同样。能够有部分甚至是所有的属性的值不同，能够有选择性的克隆，就当是标准原型模式的一个变形使用吧。
- 什么时候选用原型模式
建议在以下状况中，选用原型模式：
若是一个系统想要独立于它想要使用的对象时，可使用原型模式，让系统只面向接口编程，在系统须要新的对象的时候，能够经过克隆原型来获得；
若是须要实例化的类是在运行时刻动态指定时，可使用原型模式，经过克隆原型来获得须要的实例；
##3.7 相关模式##
- 原型模式和抽象工厂模式
功能上有些类似，都是用来获取一个新的对象实例的。
不一样之处在于，原型模式的着眼点是在如何创造出实例对象来，最后选择的方案是经过克隆；而抽象工厂模式的着眼点则在于如何来创造产品簇，至于具体如何建立出产品簇中的每一个对象实例，抽象工厂模式不是很关注。
正是由于它们的关注点不同，因此它们也能够配合使用，好比在抽象工厂模式里面，具体建立每一种产品的时候就可使用该种产品的原型，也就是抽象工厂管产品簇，具体的每种产品怎么建立则能够选择原型模式。
- 原型模式和生成器模式
这两种模式能够配合使用。
生成器模式关注的是构建的过程，而在构建的过程当中，极可能须要某个部件的实例，那么很天然地就能够应用上原型模式，经过原型模式来获得部件的实例。
- 1. prototype(原型设计模式)
- 2. 设计模式-原型（Prototype）
- 3. 【设计模式】—— 原型模式Prototype
- 4. 设计模式：原型模式（Prototype)
- 5. 设计模式（5）原型模式（Prototype）
- 6. 设计模式 | 原型模式（prototype）
- 7. 设计模式——原型模式(ProtoType)
- 8. 设计模式--原型模式(Prototype Pattern)
- 9. 设计模式（五）原型模式 Prototype
- 10. 模式设计（5）原型模式（Prototype）
- 更多相关文章...
- • Scala 模式匹配 - Scala教程
- • SVN 启动模式 - SVN 教程
- • 委托模式
- • IntelliJ IDEA代码格式化设置
-
每一个你不满意的现在，都有一个你没有努力的曾经。