原型模式

一、定义

原型模式是一种创建型设计模式。能够复制已有对象，而又无需使代码依赖它们所属的类。

二、问题

有一个订单系统，当订单中的货品数量大于1000时，那么该系统就会分拆成两个订单，如果还大于1000再拆分……
订单：id，货物名称，数量
货物：id，货物名称

三、解决方案

我们就可以使用克隆来完成对订单的复制。
创建一系列不同类型的对象并不同的方式对其进行配置。如果所需对象与预先配置的对象相同，那么你只需克隆原型即可，无需新建一个对象。
支持克隆的对象即为原型(该问题中为订单)

注意：克隆时需要注意深浅拷贝的问题！
浅拷贝：拷贝基本数据类型如 id，数量
深拷贝：拷贝引用数据类型如货物

四、代码实现

1、原型（Prototype）接口将对克隆方法进行声明。在绝大多数情况下，其中只会有一个名为 clone克隆的方法。

这里使用的是Java自带的克隆接口

package java.lang;

/**
 * A class implements the <code>Cloneable</code> interface to
 * indicate to the {@link java.lang.Object#clone()} method that it
 * is legal for that method to make a
 * field-for-field copy of instances of that class.
 * <p>
 * Invoking Object's clone method on an instance that does not implement the
 * <code>Cloneable</code> interface results in the exception
 * <code>CloneNotSupportedException</code> being thrown.
 * <p>
 * By convention, classes that implement this interface should override
 * <tt>Object.clone</tt> (which is protected) with a public method.
 * See {@link java.lang.Object#clone()} for details on overriding this
 * method.
 * <p>
 * Note that this interface does <i>not</i> contain the <tt>clone</tt> method.
 * Therefore, it is not possible to clone an object merely by virtue of the
 * fact that it implements this interface.  Even if the clone method is invoked
 * reflectively, there is no guarantee that it will succeed.
 *
 * @author  unascribed
 * @see     java.lang.CloneNotSupportedException
 * @see     java.lang.Object#clone()
 * @since   JDK1.0
 */
public interface Cloneable {
}

2、具体原型（Concrete Prototype）类将实现克隆方法。

package com.atmae.prototype;

/**
 * @Author: Mae
 * @Date: 2022/4/13
 * @Time: 11:57
 * @Description:
 */
public class Order implements Cloneable {

    public Order(Long id, Product product, Integer num) {
        this.id = id;
        this.product = product;
        this.num = num;
    }

    /**
     * 订单id号
     */
    private Long id;
    /**
     * 订单产品
     */
    private Product product;
    /**
     * 产品数量
     */
    private Integer num;


    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public Product getProduct() {
        return product;
    }

    public void setProduct(Product product) {
        this.product = product;
    }

    public Integer getNum() {
        return num;
    }

    public void setNum(Integer num) {
        this.num = num;
    }

    @Override
    public String toString() {
        return "Order{" +
                "id=" + id +
                ", product=" + product +
                ", num=" + num +
                '}'+'\n';
    }

    /**
     * 深拷贝
     * @return 订单对象
     * @throws CloneNotSupportedException 克隆？
     */
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Order order = (Order) super.clone();
        order.product= (Product) this.product.clone();
        return order;
    }
}

3、客户端

package com.atmae.prototype;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author: Mae
 * @Date: 2022/4/13
 * @Time: 13:01
 * @Description: 客户端
 */
public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        Product product = new Product("面包", 10001L);
        Order order = new Order(10000L, product, 6600);
        List<Order> orders = new ArrayList<>();
        int num=1;
        while (order.getNum() > 1000) {
            Order o = (Order) order.clone();
            o.setNum(1000);
            o.setId(order.getId()+num);
            order.setNum(order.getNum() - 1000);
            orders.add(o);
            num++;
        }
        orders.add(order);
        System.out.println(orders);
    }
}