一、原型模式定义
1.原型模式是指原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象，属于创建型模式。
2.原型模式的核心在于拷贝原型对象。以系统中已存在的一个对象为原型，直接基于内存二进制流进行拷贝，无需再经历耗时的对象初始化过程(不调用构造函数)，性能提升许多。当对象的构建过程比较耗时时，可以利用当前系统中已存在的对象作为原型，对其进行克隆(一般是基于二进制流的复制)，躲避初始化过程，使得新对象的创建时间大大减少。
3.原型模式主要包含三个角色：
A.客户(Client)：客户类提出创建对象的请求
B.抽象原型(Prototype)：规定拷贝接口
C.具体原型(Concrete Prototype)：被拷贝的对象
4.原型模式主要适用于以下场景：
A.类初始化消耗资源较多
B.new产生的一个对象需要非常繁琐的过程(数据准备、访问权限等)
C.构造函数比较复杂
D.循环体中生产大量对象
二、原型模式的通用写法
1 public interface IPrototype<T> {
2 T clone();
3 }
4
5 /**
6 * 具体需要克隆的对象
7 */
8 public class ConcretePrototype implements IPrototype {
9
10 private int age;
11 private String name;
12
13 public int getAge() {
14 return age;
15 }
16
17 public void setAge(int age) {
18 this.age = age;
19 }
20
21 public String getName() {
22 return name;
23 }
24
25 public void setName(String name) {
26 this.name = name;
27 }
28
29 @Override
30 public ConcretePrototype clone() {
31 ConcretePrototype concretePrototype = new ConcretePrototype();
32 concretePrototype.setAge(this.age);
33 concretePrototype.setName(this.name);
34 return concretePrototype;
35 }
36
37 @Override
38 public String toString() {
39 return "ConcretePrototype{"+
40 "age=" + age +
41 ", name='" + name + '\'' +
42 '}';
43 }
44 }
2.jdk自带的写法
1 /**
2 * 具体需要克隆的对象
3 */
4 public class JdkConcretePrototype implements Cloneable {
5
6 private int age;
7 private String name;
8
9 public int getAge() {
10 return age;
11 }
12
13 public void setAge(int age) {
14 this.age = age;
15 }
16
17 public String getName() {
18 return name;
19 }
20
21 public void setName(String name) {
22 this.name = name;
23 }
24
25 @Override
26 public JdkConcretePrototype clone() {
27 try {
28 return (JdkConcretePrototype)super.clone();
29 }catch (CloneNotSupportedException e){
30 e.printStackTrace();
31 return null;
32 }
33 }
34
35 @Override
36 public String toString() {
37 return "JdkConcretePrototype{"+
38 "age=" + age +
39 ", name='" + name + '\'' +
40 '}';
41 }
42 }
3.给ConcretePrototype增加一个个人爱好的属性hobbies:
1 /**
2 * 具体需要克隆的对象
3 */
4 public class JdkConcretePrototype implements Cloneable {
5
6 private int age;
7 private String name;
8 private List<String> hobbies;
9
10 public int getAge() {
11 return age;
12 }
13
14 public void setAge(int age) {
15 this.age = age;
16 }
17
18 public String getName() {
19 return name;
20 }
21
22 public void setName(String name) {
23 this.name = name;
24 }
25
26 public List<String> getHobbies() {
27 return hobbies;
28 }
29
30 public void setHobbies(List<String> hobbies) {
31 this.hobbies = hobbies;
32 }
33
34 @Override
35 public JdkConcretePrototype clone() {
36 try {
37 return (JdkConcretePrototype)super.clone();
38 }catch (CloneNotSupportedException e){
39 e.printStackTrace();
40 return null;
41 }
42 }
43
44 @Override
45 public String toString() {
46 return "JdkConcretePrototype{"+
47 "age=" + age +
48 ", name='" + name + '\'' +
49 ", hobbies=" + hobbies +
50 '}';
51 }
52 }
53
54 public class JdkPrototypeTest {
55 public static void main(String[] args) {
56 //创建原型对象
57 JdkConcretePrototype prototype = new JdkConcretePrototype();
58 prototype.setName("Tom");
59 prototype.setAge(18);
60 List<String> hobbies = new ArrayList<String>();
61 hobbies.add("美术");
62 prototype.setHobbies(hobbies);
63 System.out.println(prototype);
64
65 //拷贝原型对象
66 JdkConcretePrototype cloneType = prototype.clone();
67 cloneType.getHobbies().add("技术控");
68
69 System.out.println("原型对象：" + prototype);
70 System.out.println("克隆对象：" + cloneType);
71 }
72 }
运行后发现，给复制后的克隆对象新增一项爱好，原型对象也发生了变化，不符合我们的预期。hobbies共用了一个内存地址，意味着复制的不是值，而是引用的地址，这即是我们常说的浅克隆。
4.使用序列化实现深度克隆
1 /**
2 * 具体需要克隆的对象
3 */
4 public class JdkConcretePrototype implements Cloneable, Serializable {
5
6 private int age;
7 private String name;
8 private List<String> hobbies;
9
10 public int getAge() {
11 return age;
12 }
13
14 public void setAge(int age) {
15 this.age = age;
16 }
17
18 public String getName() {
19 return name;
20 }
21
22 public void setName(String name) {
23 this.name = name;
24 }
25
26 public List<String> getHobbies() {
27 return hobbies;
28 }
29
30 public void setHobbies(List<String> hobbies) {
31 this.hobbies = hobbies;
32 }
33
34 @Override
35 public JdkConcretePrototype clone() {
36 try {
37 return (JdkConcretePrototype)super.clone();
38 }catch (CloneNotSupportedException e){
39 e.printStackTrace();
40 return null;
41 }
42 }
43
44 public JdkConcretePrototype deepClone(){
45 try {
46 ByteArrayOutputStream bos = new ByteArrayOutputStream();
47 ObjectOutputStream oos = new ObjectOutputStream(bos);
48 oos.writeObject(this);
49
50 ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
51 ObjectInputStream ois = new ObjectInputStream(bis);
52
53 return (JdkConcretePrototype)ois.readObject();
54 }catch (Exception e){
55 e.printStackTrace();
56 return null;
57 }
58 }
59
60 @Override
61 public String toString() {
62 return "JdkConcretePrototype{"+
63 "age=" + age +
64 ", name='" + name + '\'' +
65 ", hobbies=" + hobbies +
66 '}';
67 }
68 }
5.克隆破坏单例模式，单例类不实现Cloneable接口
6.原型模式的优缺点
A.优点
a.性能优良，java自带的原型模式是基于内存二进制流的拷贝，比直接new一个对象性能上提升了许多
b.可以使用深克隆方式保存对象的状态，使用原型模式将对象复制一份并将其状态保存起来，简化了创建对象的过程，以便在需要的时候使用(例如恢复到历史某一状态)，可辅助实现撤销操作
B.缺点
a.需要为每一个类配置一个克隆方法
b.克隆方法位于类的内部，当对已有类进行改造的时候，需要修改代码，违反了开闭原则
c.在实现深克隆时需要编写较为复杂的代码，而且当对象之间存在多重嵌套引用时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现起来较为麻烦。