I. 原型模式的定义

原型（Prototype）模式的定义如下：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。

II. 原型模式的应用场景

• 对象之间相同或相似，即只是个别的几个属性不同的时候。
• 创建对象成本较大，例如初始化时间长，占用CPU太多，或者占用网络资源太多等，需要优化资源。
• 创建一个对象需要繁琐的数据准备或访问权限等，需要提高性能或者提高安全性。
• 系统中大量使用该类对象，且各个调用者都需要给它的属性重新赋值。

III. 最简单的原型模式

• 给bean类实现Cloneable接口并实现clone方法 (该方式属于浅拷贝)

public class Sheep implements Cloneable{

    private String name;
    private Integer age;
    /* 省略get/set/constructor */
    @Override
    protected Object clone(){
        Sheep sheep = null;
        try {
            sheep = (Sheep) super.clone();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sheep;
    }
}

IV. 浅拷贝与深拷贝

• 浅拷贝 : 创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。[ 比如sheep类中添加一个Sheep friend 属性，copy后，sheep1与sheep指向的friend是同一个地址，此时调用sheep.friend.setName()，sheep1中的值也会改变]
• 深拷贝 : 创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

V. 深拷贝的两种实现

1. 首先准备这样2个类，均实现Serializable & Cloneable

示例类UML

方式一 : 对引用类型逐个处理 (不推荐使用)

    @Override
    protected Object clone() {
        DeepCopy deep = null;
        try {
            deep = (DeepCopy) super.clone();
            DeepCopyInner deepCopyInner = (DeepCopyInner) deep.getDeepCopyInner().clone();
            deep.setDeepCopyInner(deepCopyInner);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return deep;
    }

方式二 : 将整个对象序列化 (推荐使用)

    @Override
    protected Object clone() {

        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;

        try {
            // 序列化
            bos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(bos);
            oos.writeObject(this); // 将当前对象以对象流的方式输出

            // 反序列化
            bis = new ByteArrayInputStream(bos.toByteArray()); // 将oos的输出读入
            ois = new ObjectInputStream(bis);
            DeepCopy deep = (DeepCopy) ois.readObject();

            return deep;
        } catch (Exception e) {
            e.printStackTrace();
            // 出现异常返回null
            return null;
        } finally {
            close(bos, oos, bis, ois);
        }

    }
    // 关闭
    private void close(ByteArrayOutputStream bos, ObjectOutputStream oos, ByteArrayInputStream bis, ObjectInputStream ois){
        try {
            bos.close();
            oos.close();
            bis.close();
            ois.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

VI. 总结

优点：

• 克隆对象比new一个对象的速度更快，开销更少
• 可以使用深拷贝保存对象在某一时刻的状态，方便撤销操作

缺点:

• 需要为每个类配置clone方法
• clone 方法位于类的内部，当对已有类进行改造的时候，需要修改代码，违背了开闭原则。