原博文:https://blog.csdn.net/KongZhongNiao/article/details/80451258
定义
用原型实例指定创建对象的种类,并通过拷贝这些原型创建新的对象。
结构和说明
- Prototype:声明一个克隆自身的接口,用来约束想要克隆自己的类,要求它们都要
实现这里定义的克隆方法。
- ConcretePrototype:实现Prototype接口的类,这些类真正实现克隆自身的功能
- Client:使用原型的客户端,首先要获取到原型实例对象,然后通过原型实例克隆
自身来创建新的对象实例。
示例代码
声明一个克隆自身的接口
package cn.javass.dp.prototype.example2;
/**
* 声明一个克隆自身的接口
*/
public interface Prototype {
/**
* 克隆自身的方法
* @return 一个从自身克隆出来的对象
*/
public Prototype clone();
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
克隆的具体实现对象1
package cn.javass.dp.prototype.example2;
/**
* 克隆的具体实现对象
*/
public class ConcretePrototype1 implements Prototype {
public Prototype clone() {
//最简单的克隆,新建一个自身对象,由于没有属性,就不去复制值了
Prototype prototype = new ConcretePrototype1();
return prototype;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
克隆的具体实现对象2
package cn.javass.dp.prototype.example2;
/**
* 克隆的具体实现对象
*/
public class ConcretePrototype2 implements Prototype {
public Prototype clone() {
//最简单的克隆,新建一个自身对象,由于没有属性,就不去复制值了
Prototype prototype = new ConcretePrototype2();
return prototype;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
使用原型的客户端
package cn.javass.dp.prototype.example2;
/**
* 使用原型的客户端
*/
public class Client {
/**
* 持有需要使用的原型接口对象
*/
private Prototype prototype;
/**
* 构造方法,传入需要使用的原型接口对象
* @param prototype 需要使用的原型接口对象
*/
public Client(Prototype prototype){
this.prototype = prototype;
}
/**
* 示意方法,执行某个功能操作
*/
public void operation(){
//会需要创建原型接口的对象
Prototype newPrototype = 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
体会原型模式
订单处理系统
考虑这样一个实际应用:订单处理系统。
现在有一个订单处理的系统,里面有个保存订单的业务功能,在这个业务
功能里面,客户有这么一个需求:每当订单的预定产品数量超过1000的时候,就
需要把订单拆成两份订单来保存,如果拆成两份订单后,还是超过1000,那就继
续拆分,直到每份订单的预定产品数量不超过1000。至于为什么要拆分,原因是
好进行订单的后续处理,后续是由人工来处理,每个人工工作小组的处理能力上
限是1000。
根据业务,目前的订单类型被分成两种:一种是个人订单,一种是公司订
单。现在想要实现一个通用的订单处理系统,也就是说,不管具体是什么类型的
订单,都要能够正常的处理。
该怎么实现呢?
不用模式的解决方案
示例代码
订单的接口
package cn.javass.dp.prototype.example1;
/**
* 订单的接口
*/
public interface OrderApi {
/**
* 获取订单产品数量
* @return 订单中产品数量
*/
public int getOrderProductNum();
/**
* 设置订单产品数量
* @param num 订单产品数量
*/
public void setOrderProductNum(int num);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
个人订单对象
package cn.javass.dp.prototype.example1;
/**
* 个人订单对象
*/
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;
}
}
- 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
企业订单对象
package cn.javass.dp.prototype.example1;
/**
* 企业订单对象
*/
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;
}
}
- 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
处理订单的业务对象
package cn.javass.dp.prototype.example1;
/**
* 处理订单的业务对象
*/
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:不超过,那就直接业务功能处理,省略了,打印输出,看一下
System.out.println("订单=="+order);
}
// public void saveOrder2(OrderApi order){
// int oldNum = order.getOrderProductNum();
// while(oldNum > 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;
// }
// //然后进行拆分和其他业务功能处理,省略了
// }
// }
}
- 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
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
客户端
package cn.javass.dp.prototype.example1;
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);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
存在的问题
仔细想想,真的没有关心订单的类型和具体实现吗?答案是“否定的”。
事实上在实现订单处理的时候,上面的实现是按照订单的类型和具体实现
来处理的,就是instanceof的那一段。有朋友可能会问,这样实现有何不可吗?
这样的实现有如下几个问题:
- (1)既然想要实现通用的订单处理,那么对于订单处理的实现对象,是不应该知道订
单的具体实现的,更不应该依赖订单的具体实现。但是上面的实现中,很明显订
单处理的对象依赖了订单的具体实现对象。 - (2)这种实现方式另外一个问题就是:难以扩展新的订单类型。假如现在要加入一个
大客户专用订单的类型,那么就需要修改订单处理的对象,要在里面添加对新的
订单类型的支持,这算哪门子的通用处理。
因此,上面的实现是不太好的,把上面的问题再抽象描述一下:**已经有了
某个对象实例后,如何能够快速简单地创建出更多的这种对象?**
使用模式的解决方案
示例代码
订单的接口,声明了可以克隆自身的方法
package cn.javass.dp.prototype.example3;
/**
* 订单的接口,声明了可以克隆自身的方法
*/
public interface OrderApi {
/**
* 获取订单产品数量
* @return 订单中产品数量
*/
public int getOrderProductNum();
/**
* 设置订单产品数量
* @param num 订单产品数量
*/
public void setOrderProductNum(int num);
/**
* 克隆方法
* @return 订单原型的实例
*/
public OrderApi cloneOrder();
}
- 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
个人订单对象
package cn.javass.dp.prototype.example3;
/**
* 个人订单对象
*/
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;
}
}
- 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
企业订单对象
package cn.javass.dp.prototype.example3;
/**
* 企业订单对象
*/
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;
}
}
- 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
处理订单的业务对象
package cn.javass.dp.prototype.example3;
/**
* 处理订单的业务对象
*/
public class OrderBusiness {
/**
* 创建订单的方法
* @param order 订单的接口对象
*/
public void saveOrder(OrderApi order){
//根据业务要求,当订单的预定的产品数量超过1000的时候,就需要把订单拆成两份订单
//当然如果要做好,这里的1000应该做成常量,这么做是为了演示简单
//1:判断当前的预定产品数量是否大于1000
while(order.getOrderProductNum() > 1000){
//2:如果大于,还需要继续拆分
//2.1再新建一份订单,跟传入的订单除了数量不一样外,其他都相同
OrderApi newOrder = order.cloneOrder();
//然后进行赋值,产品数量为1000
newOrder.setOrderProductNum(1000);
System.out.println("old order num=="+order.getOrderProductNum()+" , new Order num==="+newOrder.getOrderProductNum());
//2.2原来的订单保留,把数量设置成减少1000
order.setOrderProductNum(order.getOrderProductNum()-1000);
//然后是业务功能处理,省略了,打印输出,看一下
System.out.println("拆分生成订单=="+newOrder);
}
//3:不超过,那就直接业务功能处理,省略了,打印输出,看一下
System.out.println("订单=="+order);
}
}
- 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
客户端
package cn.javass.dp.prototype.example3;
public class OrderClient {
public static void main(String[] args) {
//创建订单对象,这里为了演示简单,直接new了
PersonalOrder op = new PersonalOrder();
//设置订单数据
op.setOrderProductNum(1925);
op.setCustomerName("张三");
op.setProductId("P0001");
//这里获取业务处理的类,也直接new了,为了简单,连业务接口都没有做
OrderBusiness ob = new OrderBusiness();
//调用业务来保存订单对象
ob.saveOrder(op);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
理解原型模式
认识原型模式
1:原型模式的功能
原型模式的功能实际上包含两个方面:
- (1)一个是通过克隆来创建新的对象实例
- (2)另一个是为克隆出来的新的对象实例复制原型实例属性的值
原型模式要实现的主要功能就是:通过克隆来创建新的对象实例。 一般来
讲,新创建出来的实例的数据是和原型实例一样的。但是具体如何实现克隆,需
要由程序自行实现,原型模式并没有统一的要求和实现算法。
2:原型与new
原型模式从某种意义上说,就像是new操作,在前面的例子实现中,克隆方
法就是使用new来实现的,但请注意,只是“类似于new”而不是“就是new”。
克隆方法和new操作最明显的不同就在于:new一个对象实例,一般属性是
没有值的,或者是只有默认值;如果是克隆得到的一个实例,通常属性是有值
的,属性的值就是原型对象实例在克隆的时候,原型对象实例的属性的值。
3:原型实例和克隆的实例
原型实例和克隆出来的实例,本质上是不同的实例,克隆完成后,它们之
间是没有关联的,如果克隆完成后,克隆出来的实例的属性的值发生了改变,是
不会影响到原型实例的。
4:原型模式的调用顺序示意图
代码示例
其他不变
客户端
package cn.javass.dp.prototype.example4;
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());
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
Java中的克隆方法
在Java语言中已经提供了clone方法,定义在Object类中。需要克隆功能的
类,只需要实现java.lang.Cloneable接口,这个接口没有需要实现的方法,是
一个标识接口。
示例代码
订单的接口,声明了可以克隆自身的方法
package cn.javass.dp.prototype.example5;
/**
* 订单的接口,声明了可以克隆自身的方法
*/
public interface OrderApi {
/**
* 获取订单产品数量
* @return 订单中产品数量
*/
public int getOrderProductNum();
/**
* 设置订单产品数量
* @param num 订单产品数量
*/
public void setOrderProductNum(int num);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
个人订单对象,利用Java的Clone功能
package cn.javass.dp.prototype.example5;
/**
* 个人订单对象,利用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;
}
@Override
public Object clone(){
//克隆方法的真正实现,直接调用父类的克隆方法就可以了
Object obj = null;
try {
obj = super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return obj;
}
}
- 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
客户端
package cn.javass.dp.prototype.example5;
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());
}
}
- 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
浅度克隆和深度克隆
什么是浅度克隆?什么是深度克隆呢?简单地解释一下:
- (1)浅度克隆:只负责克隆按值传递的数据(比如:基本数据类型、String类型)
- (2)深度克隆:除了浅度克隆要克隆的值外,还负责克隆引用类型的数据,基本上就
是被克隆实例所有的属性的数据都会被克隆出来。
深度克隆还有一个特点,如果被克隆的对象里面的属性数据是引用类型,
也就是属性的类型也是对象,那么需要一直递归的克隆下去。 这也意味着,要想
深度克隆成功,必须要整个克隆所涉及的对象都要正确实现克隆方法,如果其中
有一个没有正确实现克隆,那么就会导致克隆失败。
自定义方法示例
声明一个克隆产品自身的接口
package cn.javass.dp.prototype.example6;
/**
* 声明一个克隆产品自身的接口
*
*/
public interface ProductPrototype {
/**
* 克隆产品自身的方法
* @return 一个从自身克隆出来的产品对象
*/
public ProductPrototype cloneProduct();
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
产品对象
package cn.javass.dp.prototype.example6;
/**
* 产品对象
*/
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;
}
}
- 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
订单的接口,声明了可以克隆自身的方法
package cn.javass.dp.prototype.example6;
/**
* 订单的接口,声明了可以克隆自身的方法
*/
public interface OrderApi {
/**
* 获取订单产品数量
* @return 订单中产品数量
*/
public int getOrderProductNum();
/**
* 设置订单产品数量
* @param num 订单产品数量
*/
public void setOrderProductNum(int num);
/**
* 克隆方法
* @return 订单原型的实例
*/
public OrderApi cloneOrder();
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
个人订单对象
package cn.javass.dp.prototype.example6;
/**
* 个人订单对象
*/
public class PersonalOrder implements 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 OrderApi cloneOrder() {
//创建一个新的订单,然后把本实例的数据复制过去
PersonalOrder order = new PersonalOrder();
order.setCustomerName(this.customerName);
order.setOrderProductNum(this.orderProductNum);
//对于对象类型的数据,深度克隆的时候需要继续调用这个对象的克隆方法
order.setProduct((Product)this.product.cloneProduct());
return order;
}
}
- 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
客户端
package cn.javass.dp.prototype.example6;
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);
}
}
- 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
使用java克隆
产品对象
package cn.javass.dp.prototype.example7;
/**
* 产品对象
*/
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;
}
}
- 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
订单的接口
package cn.javass.dp.prototype.example7;
/**
* 订单的接口
*/
public interface OrderApi {
/**
* 获取订单产品数量
* @return 订单中产品数量
*/
public int getOrderProductNum();
/**
* 设置订单产品数量
* @param num 订单产品数量
*/
public void setOrderProductNum(int num);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
个人订单对象
package cn.javass.dp.prototype.example7;
/**
* 个人订单对象
*/
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;
}
}
- 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
客户端
package cn.javass.dp.prototype.example7;
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(101);
System.out.println("这是第一次获取的对象实例="+oa1);
//通过克隆来获取新的实例
PersonalOrder oa2 = (PersonalOrder)oa1.clone();
//修改它的值
oa2.getProduct().setName("产品2");
oa2.setOrderProductNum(81);
//输出克隆出来的对象的值
System.out.println("输出克隆出来的实例="+oa2);
//再次输出原型实例的值
System.out.println("再次输出原型实例="+oa1);
}
}
- 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
原型管理器
如果一个系统中原型的数目不固定,比如系统中的原型可以被动态的创建
和销毁,那么就需要在系统中维护一个当前可用的原型的注册表,这个注册表就
被称为原型管理器。
其实如果把原型当成一个资源的话,原型管理器就相当于一个资源管理
器,在系统开始运行的时候初始化,然后运行期间可以动态的添加资源和销毁资
源。从这个角度看,原型管理器就可以相当于一个缓存资源的实现,只不过里面
缓存和管理的是原型实例而已。
有了原型管理器过后,一般情况下,除了向原型管理器里面添加原型对象
的时候是通过new来创造的对象,其余时候都是通过向原型管理器来请求原型实
例,然后通过克隆方法来获取新的对象实例,这就可以实现动态管理、或者动态
切换具体的实现对象实例。
示例代码
接口
package cn.javass.dp.prototype.example8;
public interface Prototype {
public Prototype clone();
public String getName();
public void setName(String name);
}
- 1
- 2
- 3
- 4
- 5
- 6
克隆的具体实现对象
package cn.javass.dp.prototype.example8;
/**
* 克隆的具体实现对象
*/
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;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
克隆的具体实现对象
package cn.javass.dp.prototype.example8;
/**
* 克隆的具体实现对象
*/
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;
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
原型管理器
package cn.javass.dp.prototype.example8;
import java.util.*;
/**
* 原型管理器
*/
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;
}
}
- 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
客户端
package cn.javass.dp.prototype.example8;
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());
}
}
}
- 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
原型模式的优缺点
- 1:对客户端隐藏具体的实现类型
- 2:在运行时动态改变具体的实现类型
- 3:深度克隆方法实现会比较困难
思考原型模式
原型模式的本质
原型模式的本质是:==克隆生成对象==
何时选用原型模式
1:如果一个系统想要独立于它想要使用的对象时,可以使用原型模式,让系统只面
向接口编程,在系统需要新的对象的时候,可以通过克隆原型来得到2:如果需要实例化的类是在运行时刻动态指定时,可以使用原型模式,通过克隆原
型来得到需要的实例