设计模式之原型模式(Prototype Pattern)

原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。

这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

原型模式的特点：

1、过程相同，结果不一样。
2、数据内容一样，但是实例不同。
3、只支持java的8大数据类型和String，其它类型为引用。可以理解为栈复制，浅拷贝；可以手动实现深拷贝；
通俗的讲就是字节码复制；

具体表现是，将现有对象的值，赋给另一个新的对象，值一模一样。（跟a=b，不同。a=b只是引用，而原型模式是克隆了一个一模一样的对象）

代码示例：
浅拷贝：
public class Monkey implements Cloneable{
    private int age;
    private float height;
    private float weight;
    private Date birthday;
    private Equipment equipment;
    private ArrayList<String> doings;
    @Override
    protected Object clone() throws CloneNotSupportedException {        
        return super.clone();
    }
}
深拷贝：
public class Monkey implements Cloneable{
    private int age;
    private float height;
    private float weight;
    private Date birthday;
    private Equipment equipment;
    private ArrayList<String> doings;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        //只是clone（）属于浅拷贝
        Monkey monkey = (Monkey) super.clone();
        //手动操作属于深拷贝
        monkey.birthday = (Date) birthday.clone();
        monkey.equipment = (Equipment) equipment.clone();
        monkey.doings = (ArrayList<String>) doings.clone();
        //也可以通过序列化来实现深拷贝
        return monkey;
    }
}
自定义对象：
public class Equipment implements Cloneable{
    private String color;
    private String weight;
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public String getWeight() {
        return weight;
    }
    public void setWeight(String weight) {
        this.weight = weight;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
测试代码：
public static void main(String[] args) throws InterruptedException {
        Monkey monkey = new Monkey();
        monkey.setAge(18);
        monkey.setHeight(150);
        monkey.setWeight(50);
        monkey.setBirthday(new Date());
        Equipment equipment = new Equipment();
        equipment.setColor("black");
        monkey.setEquipment(equipment);
        ArrayList<String> list = new ArrayList<String>();
        list.add("one");
        monkey.setDoings(list);
        System.out.println("原始对象："+monkey);
        Thread.sleep(2);
        try {
            Monkey copyMonkey = (Monkey) monkey.clone();
            System.out.println("拷贝对象："+copyMonkey);
            copyMonkey.setAge(0);
            copyMonkey.setHeight(10);
            copyMonkey.setWeight(10);
            copyMonkey.getBirthday().setTime(new Date().getTime());
            copyMonkey.getEquipment().setColor("white");
            copyMonkey.getDoings().add("two");
            System.out.println("拷贝赋新值后的原始对象："+monkey);
            System.out.println("拷贝赋新值后的拷贝对象："+copyMonkey);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
测试结果：
浅拷贝：

深拷贝：

结果分析：
通过比较发现，浅拷贝下非基本类型克隆的只是类型的对象在堆中的地址，克隆对象修改了值，原始对象也会改变；而深拷贝实现了这些复杂对象的拷贝，使得克隆对象中的成员拥有新的对象地址。