原型模式

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

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

使用场景：

1. 当一个系统应该独立于它的产品创建，构成和表示时。
2. 当要实例化的类是在运行时刻指定时，例如，通过动态装载。
3. 为了避免创建一个与产品类层次平行的工厂类层次时。
4. 当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。

简单的说，原型模式就是复制一个原有的对象，在Java中复制对象的方法有：

1、手动将实例A的值赋值给实例B 

1、通过重写java.lang.Object类中的方法clone()； 

2、通过序列化、反序列化实现对象的复制。

---

 1、重写java.lang.Object类中的方法clone()：

Java中克隆分为深克隆和浅克隆

浅克隆：克隆对象时仅仅拷贝对象本身（基本数据类型和String），而不克隆引用的其他对象

深克隆：不仅克隆对象本身，而且克隆对象包含的引用指向的所有对象。

Cast1：浅克隆

准备猴类和猪类：因为要克隆猴类，所以要实现Cloneable接口，重写Clone()方法

// 实现 Cloneable 接口
class Monkey implements Cloneable {
    public String name;
    public int age;
    Pig friend;

    public Monkey(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //重写 clone() 方法
    @Override
    public Object clone() {
        Monkey monkey = null;
        try {
            monkey = (Monkey) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return monkey;
    }

    @Override
    public String toString() {
        return "Monkey{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", friend=" + friend +
                '}';
    }
}

class Pig {
    String name;

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

    @Override
    public String toString() {
        return "Pig{" +
                "name='" + name + '\'' +
                '}';
    }
}

Test：

public static void main(String[] args) {
    Monkey monkey = new Monkey("孙悟空", 800);
    monkey.friend = new Pig("佩奇");

    Monkey monkey2 = (Monkey) monkey.clone();
    System.out.println("------------------------Monkey1------------------------");
    System.out.println(monkey);
    System.out.println("monkey = " + monkey.hashCode());

    System.out.println("------------------------Monkey2------------------------");
    System.out.println(monkey2);
    System.out.println("monkey2 = " + monkey2.hashCode());
    System.out.println("monkey == monkey2 ? " + (monkey == monkey2));
    System.out.println("\nmonkey.friend : " + monkey.friend.hashCode());
    System.out.println("monkey2.friend : " + monkey2.friend.hashCode());
    System.out.println("monkey.friend == monkey2.friend ? " + (monkey.friend == monkey2.friend));

}

结果：如图，monkey2克隆了monkey，两者不是同一个实例，但是monkey引用的pig类(monkey.friend)为同一实例

 

 Cast2：深克隆

因为Pig也要被克隆，所以也要重写Clone()方法：

class Pig implements Cloneable {
    String name;

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

    @Override
    public String toString() {
        return "Pig{" +
                "name='" + name + '\'' +
                '}';
    }

    @Override
    public Object clone() {
        Pig pig = null;
        try {
            pig = (Pig) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return pig;
    }
}

同时，Monkey类的Clone方法也进行修改（先克隆基础数据类型，在一一克隆引用的对象）

@Override
public Object clone() {
    Monkey monkey = null;
    try {
        monkey = (Monkey) super.clone();
    } catch (CloneNotSupportedException e) {
        e.printStackTrace();
    }
    monkey.friend = (Pig) monkey.friend.clone();
    return monkey;
}

结果：

 分析：这种方法确实可以实现深克隆，但假设Pig类也引用了其他对象，则需要递归克隆引用的对象，不好实现，如果引用的对象是循环链表可能会无法收敛。

2、通过序列化、反序列化实现对象的复制

序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程，反序列化则是将流转换为对象。

java.io.ObjectOutputStream：对象输出流

　　writeObject(Object obj) 将obj序列化，把得到的字节序列写到目标输出到流中；

java.io.ObjectInputStream：对象输入流

　　readObject() 读取字节序列，反序列化为新对象

/**
 * @param obj 原型对象
 * @return 克隆对象
 */
static Object SerialClone(Object obj) {
    ByteArrayOutputStream bos = null;
    ObjectOutputStream oos = null;
    ByteArrayInputStream bis = null;
    ObjectInputStream ois = null;
    Object copyObj = null;
    try {
        // 序列化
        bos = new ByteArrayOutputStream();
        oos = new ObjectOutputStream(bos);
        oos.writeObject(obj);
        // 反序列化
        bis = new ByteArrayInputStream(bos.toByteArray());
        ois = new ObjectInputStream(bis);
        copyObj = ois.readObject();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (ois != null) ois.close();
            if (bis != null) bis.close();
            if (oos != null) oos.close();
            if (bos != null) bos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    return copyObj;
}

PS：序列化还有很多其他方法，不在讨论 

总结：

在创建复杂对象，可以使用原型模式简化创建对象的过程，同时提高效率

克隆对象可以动态获取该对象的运行时状态

缺点：需要让每个类重写clone方法或实现Serializable接口（其实是个空接口，但是还是要implement），如果要克隆已有的类则需要修改源代码，违背OCP原则