设计模式学习--------10.原型模式学习
场景:
一个订单系统,里面有一个保存订单的业务功能。具体需求:每当订单的预订产品超过1000的时候，需要把订单拆分
成两份订单。如果拆分成两份后还是超过1000，则继续拆分。订单类型分为个人订单和公司订单,不管是什么类型的订
单，都要能够正常地处理.抽象的描述下就是已经有了某个对象实例后,如何能够快速的创建出更多的这种对象。
定义：
用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。
角色：
Prototype: 声明一个克隆自身的接口,用来约束想要克隆自己的类，要求他们都要实现这里定义的克隆方法。
package com.kris.study;
public interface Prototype {
public Prototype cloneItem();
public void display();
}
ConcretePrototype:实现Prototype接口的类,这些类真正实现了克隆自身的功能
package com.kris.study;
public class ConcretePrototype2 implements Prototype {
@Override
public Prototype cloneItem() {
return new ConcretePrototype2();
}
@Override
public void display() {
System.out.println("ConcretePrototype2 display");
}
}
package com.kris.study;
public class ConcretePrototype1 implements Prototype {
@Override
public Prototype cloneItem() {
return new ConcretePrototype1();
}
@Override
public void display() {
System.out.println("ConcretePrototype1 display");
}
}
Client客户端：
package com.kris.study;
public class Client {
private Prototype prototype;
public Client(Prototype prototype){
this.prototype = prototype;
}
public void operation(){
Prototype newPrototype = prototype.cloneItem();
newPrototype.display();
}
}
使用JAVA中的克隆方法实现原型模式解决场景的问题：
Order：订单类
package com.kris.study;
public abstract class Order implements Cloneable{
private String productId;
private int orderProductNum = 0;
public abstract void setName(String name);
public abstract String display();
public String getProductId() {
return productId;
}
public void setProductId(String productId) {
this.productId = productId;
}
public int getOrderProductNum() {
return orderProductNum;
}
public void setOrderProductNum(int orderProductNum) {
this.orderProductNum = orderProductNum;
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
PersonalOrder：个人订单类
package com.kris.study;
public class PersonalOrder extends Order {
private String personalName;
@Override
public String display() {
return "PersonalName:"+personalName;
}
@Override
public void setName(String name) {
this.personalName = name;
}
}
EnterpriseOrder：公司订单类
package com.kris.study;
public class EnterpriseOrder extends Order {
private String enterpriseName;
@Override
public String display() {
return "EnterpriseName:"+enterpriseName;
}
@Override
public void setName(String name) {
this.enterpriseName = name;
}
}
OrderBiz：订单业务
package com.kris.study;
public class OrderBiz {
public void saveOrder(Order order){
while(order.getOrderProductNum()>1000){
try {
Order newOrder = (Order) order.clone();
newOrder.setOrderProductNum(1000);
order.setOrderProductNum(order.getOrderProductNum()-1000);
System.out.println("new order info ==> name: "+newOrder.display()+" productId:"
+newOrder.getProductId()+" productNum:"+newOrder.getOrderProductNum());
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
System.out.println("old order info ==> name: "+order.display()+" productId:"
+order.getProductId()+" productNum:"+order.getOrderProductNum());
}
}
Client:客户端
package com.kris.study;
public class Client {
public static void main(String[] args) {
Order order = new PersonalOrder();
order.setName("John");
order.setProductId("111");
order.setOrderProductNum(3422);
new OrderBiz().saveOrder(order);
}
}
深克隆和浅克隆
浅克隆：只负责克隆按值传递的数据(比如基本数据类型,String类型)。
深克隆：除了浅克隆要克隆的值外，还负责克隆引用类型的数据。
引用类型需要递归实现Cloneable接口。
JAVA中实现深克隆：
package com.kris.study;
public class Product implements Cloneable {
private String productId;
private String name;
public String getProductId() {
return productId;
}
public void setProductId(String productId) {
this.productId = productId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Product [productId=" + productId + ", name=" + name + "]";
}
@Override
public Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
package com.kris.study;
public class PersonalOrder implements Cloneable {
private String customerName;
private Product product = null;
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;
}
@Override
public String toString() {
return "PersonalOrder [customerName=" + customerName + ", product="
+ product + "]";
}
@Override
public Object clone() throws CloneNotSupportedException {
PersonalOrder obj = (PersonalOrder) super.clone();
//关键的一句话
obj.setProduct((Product) this.product.clone());
return obj;
}
}
原理分析：
本质：克隆生成新对象
优点：对客户端隐藏具体实现
缺点：每个原型的子类必须实现clone的操作。
