1：原型模式的本质
原型模式的本质：克隆生成对象。
克隆是手段。目的还是生成新的对象实例。正是由于原型的目的是为了生成新的对象实例。原型模式一般是被归类为创建型的模式。
原型模式也能够用来解决“仅仅知接口而不知实现的问题”，使用原型模式，能够出现一种独特的“接口造接口”的景象，这在面向接口编程中非常实用。相同的功能也能够考虑使用工厂来实现。
另外。原型模式的重心还是在创建新的对象实例。至于创建出来的对象，其属性的值是否一定要和原型对象属性的值全然一样，这个并没有强制规定。仅仅只是在眼下大多数实现中，克隆出来的对象和原型对象的属性值是一样的。
也就是说，能够通过克隆来创造值不一样的实例，可是对象类型必须一样。
能够有部分甚至是所有的属性的值不一样，能够有选择性的克隆，就当是标准原型模式的一个变形使用吧。
2：何时选用原型模式
建议在例如以下情况中，选用原型模式：
- 假设一个系统想要独立于它想要使用的对象时，能够使用原型模式，让系统仅仅面向接口编程。在系统须要新的对象的时候，能够通过克隆原型来得到
- 假设须要实例化的类是在执行时刻动态指定时，能够使用原型模式。通过克隆原型来得到须要的实例
原型模式和抽象工厂模式
功能上有些相似。都是用来获取一个新的对象实例的。
不同之处在于，原型模式的着眼点是在怎样创造出实例对象来。最后选择的方案是通过克隆；而抽象工厂模式的着眼点则在于怎样来创造产品簇，至于详细怎样创建出产品簇中的每一个对象实例，抽象工厂模式不是非常关注。
正是由于它们的关注点不一样，所以它们也能够配合使用，比方在抽象工厂模式里面，详细创建每一种产品的时候就能够使用该种产品的原型。也就是抽象工厂管产品簇。详细的每种产品怎么创建则能够选择原型模式。
原型模式和生成器模式
这两种模式能够配合使用。
生成器模式关注的是构建的过程。而在构建的过程中。非常可能须要某个部件的实例，那么非常自然地就能够应用上原型模式，通过原型模式来得到部件的实例
1）原型模式的功能
原型模式的功能实际上包括两个方面：
- 一个是通过克隆来创建新的对象实例
- 还有一个是为克隆出来的新的对象实例复制原型实例属性的值
原型模式要实现的主要功能就是：通过克隆来创建新的对象实例。一般来讲，新创建出来的实例的数据是和原型实例一样的。可是详细怎样实现克隆。须要由程序自行实现，原型模式并没有统一的要求和实现算法。
（2）原型与new
原型模式从某种意义上说。就像是new操作，在前面的样例实现中，克隆方法就是使用new来实现的。但请注意，仅仅是“类似于new”而不是“就是new”。
克隆方法和new操作最明显的不同就在于：new一个对象实例，一般属性是没有值的。或者是仅仅有默认值；假设是克隆得到的一个实例，通常属性是有值的，属性的值就是原型对象实例在克隆的时候，原型对象实例的属性的值。
（3）原型实例和克隆的实例
原型实例和克隆出来的实例，本质上是不同的实例。克隆完毕后，它们之间是没有关联的。假设克隆完毕后，克隆出来的实例的属性的值发生了改变，是不会影响到原型实例的。以下写个演示样例来測试一下。演示样例代码例如以下
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
细致观察上面的结果，会发现原型实例和克隆出来的实例是全然独立的，也就是它们指向不同的内存空间。由于克隆出来的实例的值已经被改变了。而原型实例的值还是原来的值，并没有变化，这就说明两个实例是相应的不同内存空间。
（4）原型模式的调用顺序示意图
原型模式的调用顺序如图所看到的：
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;
}
}
看起来，比全然由自己实现原型模式要稍稍简单点，是否好用呢？还是測试一下，看看效果。client跟上一个演示样例相比，作了两点改动：
- 一个是原来的“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());
}
}
浅度克隆和深度克隆
不管你是自己实现克隆方法，还是採用Java提供的克隆方法，都存在一个浅度克隆和深度克隆的问题，那么什么是浅度克隆？什么是深度克隆呢？简单地解释一下：
- 浅度克隆：仅仅负责克隆按值传递的数据（比方：基本数据类型、String类型）
- 深度克隆：除了浅度克隆要克隆的值外，还负责克隆引用类型的数据，基本上就是被克隆实例全部的属性的数据都会被克隆出来。
深度克隆另一个特点，假设被克隆的对象里面的属性数据是引用类型，也就是属性的类型也是对象。那么需要一直递归的克隆下去。这也意味着，要想深度克隆成功，必需要整个克隆所涉及的对象都要正确实现克隆方法。假设当中有一个没有正确实现克隆，那么就会导致克隆失败。
在前面的样例中实现的克隆就是典型的浅度克隆，以下就来看看怎样实现深度克隆。
1：自己实现原型的深度克隆
（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）写个client来測试看看，是否深度克隆成功，演示样例代码例如以下：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）小结
看来自己实现深度克隆也不是非常复杂，可是比較麻烦，假设产品类里面又有属性是引用类型的话，在产品类实现克隆方法的时候。又须要调用那个引用类型的克隆方法了。这样一层一层调下去，假设中途有不论什么一个对象没有正确实现深度克隆，那将会引起错误，这也是深度克隆easy出错的原因。
2：Java中的深度克隆
利用Java中的clone方法来实现深度克隆，大体上和自己做差点儿相同，可是也有一些须要注意的地方，一起看看吧。
（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()所拷贝的值。
（4）client測试类跟刚才自己做的深度拷贝差点儿相同，仅仅是调用克隆的方法，原来是调用的cloneOrder方法，如今变成调用clone()。执行測试看看。执行结果例如以下：
这是第一次获取的对象实例=订购产品是=产品1，订购数量为=100
输出克隆出来的实例=订购产品是=产品2，订购数量为=80
再次输出原型实例=订购产品是=产品1。订购数量为=100
注意观察上面的数据，非常明显这是正确的。改动克隆出来的实例的属性值，不会影响到原对象实例的属性的值。
（5）以下去掉“obj.setProduct((Product)this.product.clone());”这句话，看看会发生什么，执行结果例如以下：
这是第一次获取的对象实例=订购产品是=产品1。订购数量为=100
输出克隆出来的实例=订购产品是=产品2，订购数量为=80
再次输出原型实例=订购产品是=产品2。订购数量为=100
细致观察一下。尤其是加粗的两行。你就会发现，改动克隆对象实例的产品名称属性的值，影响了原型对象实例的值。这说明没有正确深度克隆。
原型管理器
假设一个系统中原型的数目不固定，比方系统中的原型能够被动态的创建和销毁，那么就须要在系统中维护一个当前可用的原型的注冊表，这个注冊表就被称为原型管理器。
事实上假设把原型当成一个资源的话，原型管理器就相当于一个资源管理器。在系统開始执行的时候初始化。然后执行期间能够动态的加入资源和销毁资源。从这个角度看。原型管理器就能够相当于一个缓存资源的实现，仅仅只是里面缓存和管理的是原型实例而已。
有了原型管理器过后，普通情况下，除了向原型管理器里面加入原型对象的时候是通过new来创造的对象，其余时候都是通过向原型管理器来请求原型实例，然后通过克隆方法来获取新的对象实例，这就能够实现动态管理、或者动态切换详细的实现对象实例。
还是通过演示样例来说明，怎样实现原型管理器。
（1）先定义原型的接口。很easy。除了克隆方法，提供一个名称的属性。演示样例代码例如以下：
public interface Prototype {
public Prototype clone();
public String getName();
public void setName(String name);
}（2）再来看看两个详细的实现，实现方式基本上是一样的，分别看看。先看第一个原型的实现，演示样例代码例如以下：
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;
}
}（3）接下来看看原型管理器的实现示意，演示样例代码例如以下：/**
* 原型管理器
*/
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属性非常明显就成了大家竞争的资源，因此须要加上同步。
（4）接下来看看client，怎样使用这个原型管理器，演示样例代码例如以下：
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=李四
您希望获取的原型还没有注冊或已被销毁
原型模式的优缺点
对client隐藏详细的实现类型
原型模式的client。仅仅知道原型接口的类型，并不知道详细的实现类型。从而降低了client对这些详细实现类型的依赖。
在执行时动态改变详细的实现类型
原型模式能够在执行期间，由客户来注冊符合原型接口的实现类型，也能够动态的改变详细的实现类型，看起来接口没有不论什么变化，但事实上执行的已经是另外一个类实例了。由于克隆一个原型就类似于实例化一个类。
深度克隆方法实现会比較困难
原型模式最大的缺点就在于每一个原型的子类都必须实现clone的操作。尤其在包括引用类型的对象时，clone方法会比較麻烦，必需要可以递归的让全部的相关对象都要正确的实现克隆。
举报
- 本文已收录于下面专栏：
相关文章推荐
-
【JavaScript】prototype简单解释
js学习小结
- u010942420
- 2016-07-06 20:41
- 252
-
欢迎使用CSDN-markdown编辑器
javascript高程小结纯手打 function fn() { var val = 1; //私有基础属性 var arr = [...
- Camel_tong
- 2017-03-07 22:45
- 21
-
设计模式之Prototype（c++）
Prototype模型： 用原型实例指定创建对象的种类。而且通过拷贝这些原型创建新的对象----克隆（clone）对象。
- richerg85
- 2013-12-04 22:03
- 1621
-
深入浅出设计模式 ------ Prototype(原型模式)
代码是利用JDK自带的clone()实现Prototype模式， 这里面的clone()使用的是浅克隆。 浅克隆 : 仅仅负责克隆按值传递的数据（比方基本数据类型、String类型）。而不...
- wenniuwuren
- 2015-02-02 09:36
- 1406
-
Java 实现原型(Prototype)模式
[java] view plaincopyprint? public class BaseSpoon implements Cloneable {//spoon 匙, 调...
- shineflowers
- 2014-12-02 18:33
- 832
-
怎样理解原型模式(Prototype)解析（包括源代码）
怎样理解原型模式(Prototype)解析（包括源代码） JavaScript教程 摘要：本文深入浅出的讲述了设计模式中的原型模式,并给出了简单的演示样例,样例浅显易懂,并附带源码。 原型模...
- mynote
- 2015-03-14 10:27
- 402
-
设计模式（四）原型模式Prototype（创建型）
设计模式（四）原型模式Prototype 1. 概述 我们都知道。创建型模式通常是用来创建一个新的对象。然后我们使用这个对象完毕一些对象的操作，我们通过原型模式能够高速的...
- hguisu
- 2012-05-02 10:19
- 20476
-
设计模式（五）：原型模式Prototype（创建型模式）
用原型实例指定创建对象的种类。而且通过拷贝这些原型创建新的对象。一. 适用性1.当一个系统应该独立于它的产品创建、构成和表示时。2.当要实例化的类是在执行时刻指定时，比如，通过动态装载。3.为了避免创...
- u011008029
- 2016-07-15 14:39
- 160
-
Prototype模式
Prototype模式 一、意图： 用原型实例指定创建对象的种类，而且通过拷贝这些原则创建新的对象。(复制构造函数) 二、C++演示样例： #include using ...
- u010002704
- 2014-11-29 22:43
- 574
-
java原型模式（Prototype）-创建型
java原型模式 Prototype模式
- sunxianghuang
- 2016-07-03 15:56
- 397
1条评论