https://www.cnblogs.com/lfxiao/p/6812835.html
https://www.cnblogs.com/liaoweipeng/p/5768645.html

原型模式就是用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。在原型模式中，所发动创建的对象通过请求原型对象来拷贝原型对象自己来实现创建过程，当然所发动创建的对象需要知道原型对象的类型。这里也就是说所发动创建的对象只需要知道原型对象的类型就可以获得更多的原型实例对象，至于这些原型对象时如何创建的根本不需要关心。

UML图如下所示：

java中复制通过clone()实现的。clone中涉及深、浅复制。深、浅复制的概念如下：

浅复制

被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。 Object类提供的方法clone只是拷贝本对象，其对象内部的数组、引用对象等都不拷贝，还是指向原生对象的内部元素地址。

深复制

被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。 

浅复制实现：

Address

public class Address {
    private String province;//省
    private String city;//市

    public Address(String province, String city) {
        this.province = province;
        this.city = city;
    }

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }
}

Prototype

public class Prototype implements Cloneable {
    private String name;//名字
    private Address address;

    public Prototype(String name) {
        this.name = name;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Object clone() throws CloneNotSupportedException {
        Prototype proto = (Prototype) super.clone();
        return proto;
    }
}

Client

public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        Prototype p1 = new Prototype("张三");
        p1.setAddress(new Address("江西", "赣州"));
        p1.setName("张三");
        Prototype p2 = (Prototype) p1.clone();
        p2.setName("李四");
        p2.getAddress().setProvince("北京");
        System.out.println(p2.getName() + p2.getAddress().getProvince());
        System.out.println(p1.getName() + p1.getAddress().getProvince());
    }
}

输出结果如下：

可以看出来对象并复制，依然使用的是同一个引用。其对象内部的数组、引用对象等都不拷贝，还是指向原生对象的内部元素地址。

深复制实现

Address

public class Address implements Cloneable {
    private String province;//省
    private String city;//市


    public Object clone() {

        Address address = null;
        try {
            address = (Address) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return address;
    }

    public Address(String province, String city) {
        this.province = province;
        this.city = city;
    }

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }
}

Prototype

public class Prototype implements Cloneable {
    private String name;//名字
    private Address address;

    public Prototype(String name) {
        this.name = name;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Object clone() throws CloneNotSupportedException {
        Prototype proto = (Prototype) super.clone();
        proto.address=(Address) address.clone();
        return proto;
    }
}

Client

public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        Prototype p1 = new Prototype("张三");
        p1.setAddress(new Address("江西", "赣州"));
        p1.setName("张三");
        Prototype p2 = (Prototype) p1.clone();
        p2.setName("李四");
        p2.getAddress().setProvince("北京");
        System.out.println(p2.getName() + p2.getAddress().getProvince());
        System.out.println(p1.getName() + p1.getAddress().getProvince());
    }
}

输出结果如下：

总结

原型模式作为一种快速创建大量相同或相似对象的方式，在软件开发中应用较为广泛，很多软件提供的复制(Ctrl + C)和粘贴(Ctrl + V)操作就是原型模式的典型应用，下面对该模式的使用效果和适用情况进行简单的总结。

优点

(1) 当创建新的对象实例较为复杂时，使用原型模式可以简化对象的创建过程，通过复制一个已有实例可以提高新实例的创建效率。

(2) 扩展性较好，由于在原型模式中提供了抽象原型类，在客户端可以针对抽象原型类进行编程，而将具体原型类写在配置文件中，增加或减少产品类对原有系统都没有任何影响。

(3) 原型模式提供了简化的创建结构，工厂方法模式常常需要有一个与产品类等级结构相同的工厂等级结构，而原型模式就不需要这样，原型模式中产品的复制是通过封装在原型类中的克隆方法实现的，无须专门的工厂类来创建产品。

(4) 可以使用深克隆的方式保存对象的状态，使用原型模式将对象复制一份并将其状态保存起来，以便在需要的时候使用（如恢复到某一历史状态），可辅助实现撤销操作。

缺点

(1) 需要为每一个类配备一个克隆方法，而且该克隆方法位于一个类的内部，当对已有的类进行改造时，需要修改源代码，违背了“开闭原则”。

(2) 在实现深克隆时需要编写较为复杂的代码，而且当对象之间存在多重的嵌套引用时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现起来可能会比较麻烦。

应用场景

(1) 创建新对象成本较大（如初始化需要占用较长的时间，占用太多的CPU资源或网络资源），新的对象可以通过原型模式对已有对象进行复制来获得，如果是相似对象，则可以对其成员变量稍作修改。

(2) 如果系统要保存对象的状态，而对象的状态变化很小，或者对象本身占用内存较少时，可以使用原型模式配合备忘录模式来实现。

(3) 需要避免使用分层次的工厂类来创建分层次的对象，并且类的实例对象只有一个或很少的几个组合状态，通过复制原型对象得到新实例可能比使用构造函数创建一个新实例更加方便。