原型模式
前言
原型模式属于对象的创建模式。通过给出一个原型对象来指明所有创建的对象的类型，然后用复制这个原型对象的办法创建出更多同类型的对象。这就是选型模式的用意。
克隆羊问题：
现在有一只羊tom，姓名为: tom, 年龄为：1，颜色为：白色，请编写程序创建和tom 羊 属性完全相同的10只羊。
传统方式解决克隆羊问题：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2 * @author 孙一鸣 on 2020/2/6
3 */
4public class Client {
5
6 public static void main(String[] args) {
7 Sheep sheep =new Sheep("tom",1,"白色");
8 Sheep sheep1 =new Sheep(sheep.getName(),sheep.getAge(),sheep.getColor());
9 Sheep sheep2 = new Sheep(sheep.getName(),sheep.getAge(),sheep.getColor());
10 Sheep sheep3 = new Sheep(sheep.getName(),sheep.getAge(),sheep.getColor());
11 Sheep sheep4 = new Sheep(sheep.getName(),sheep.getAge(),sheep.getColor());
12 Sheep sheep5 =new Sheep(sheep.getName(),sheep.getAge(),sheep.getColor());
13
14 System.out.println(sheep1);
15 System.out.println(sheep2);
16 System.out.println(sheep3);
17 }
18}
19
20
21
传统的方式的优缺点 ：
- 优点是比较好理解，简单易操作。
- 在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂
时，效率较低（
因为是克隆，所以属性值要相同）
- 总是需要重新初始化对象，而不是动态地获得对象运行时的状态, 不够灵活
- 改进的思路分析
思路：
Java中Object类是所有类的根类，Object类提供了一个clone()方法，该方法可以
将一个Java对象复制一份，但是需要实现clone的Java类必须要实现一个
接口Cloneabl 该接口表示该类能够复制且具有复制的能力 =>
原型模式
原型模式:
基本介绍:
此处引用https://blog.csdn.net/qq_40709468/article/details/82316418
多重影分身非常合适这个概念，鸣人本体是原型对象！通过“多重影分身术”也就是原型模式（自己本身使用忍术进行创建），进行分身！创建新对象，（分身）。
需要注意的是，创建新“分身”的人就是鸣人！这个意思就是说原型对象自己不仅是个对象还是个工厂！并且通过
克隆方式创建的对象是
全新的对象，它们都是有自己的新的地址，通常对克隆模式所产生的新对象（影分身）进行修改（攻击）是不会对原型对象（鸣人）造成任何影响的！，每一个克隆对象都是相对独立的，通过不同的方式对克隆对象进行修改后，可以的到一系列相似但不完全相同的对象。（参考多重影分身之色诱术）。
原型模式要求对象实现一个可以“克隆”自身的接口，这样就可以通过复制一个实例对象本身来创建一个新的实例。这样一来，通过原型实例创建新的对象，就不再需要关心这个实例本身的类型，只要实现了克隆自身的方法，就可以通过这个方法来获取新的对象，而无须再去通过new来创建。
sheep类实现cloneable接口：
2
3
4
5
6
7
8
9
10
11
12
13
2 @Override
3 protected Object clone() {
4 Sheep sheep=null;
5 try{
6 sheep= (Sheep) super.clone();
7 }catch (Exception e){}
8 return sheep;
9 }
10}
11
12
13
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2 * @author 孙一鸣 on 2020/2/6
3 */
4public class Client {
5
6 public static void main(String[] args) {
7 Sheep sheep =new Sheep("tom",1,"白色");
8 Sheep sheep1 =(Sheep)sheep.clone();
9 Sheep sheep2 =(Sheep)sheep .clone();
10 Sheep sheep3 =(Sheep)sheep.clone();
11
12
13 System.out.println(sheep1);
14 System.out.println(sheep2);
15 System.out.println(sheep3);
16 }
17}
18
19
20
深入讨论-浅拷贝和深拷贝
Java的所有类都是从java.lang.Object类继承而来的，而Object类提供protected Object clone()方法对对象进行复制，子类当然也可以把这个方法置换掉，提供满足自己需要的复制方法。对象的复制有一个基本问题，就是对象通常都有对其他的对象的引用。当使用Object类的clone()方法来复制一个对象时，此对象对其他对象的引用也同时会被复制一份
Java语言提供的Cloneable接口只起一个作用，就是在运行时期通知Java虚拟机可以安全地在这个类上使用clone()方法。通过调用这个clone()方法可以得到一个对象的复制。由于Object类本身并不实现Cloneable接口，因此如果所考虑的类没有实现Cloneable接口时，调用clone()方法会抛出CloneNotSupportedException异常。
克隆满足的条件
clone()方法将对象复制了一份并返还给调用者。所谓“复制”的含义与clone()方法是怎么实现的。一般而言，clone()方法满足以下的描述：
2
3
4
5
2- 对任何的对象x，都有：x.clone().getClass() == x.getClass()，换言之，克隆对象与原对象的类型一样。
3- 如果对象x的equals()方法定义其恰当的话，那么x.clone().equals(x)应当成立的。
4
5
在JAVA语言的API中，凡是提供了clone()方法的类，都满足上面的这些条件。JAVA语言的设计师在设计自己的clone()方法时，也应当遵守着三个条件。一般来说，上面的三个条件中的前两个是必需的，而第三个是可选的
浅拷贝基本介绍：
- 对于数据类型是
基本数据类型的成员变量，
浅拷贝会直接进行
值传递，也就是将
该属性值复制一份给新的对象。
- 对于数据类型是
引用数据类型的成员变量，比如说成员变量是
某个数组、某个类
的对象等，那么浅拷贝会进行
引用传递，也就是只是将该成员变量的引用值（内
存地址）复制一份给新的对象。因为
实际上两个对象的该成员变量都指向同一个
实例。在这种情况下，在一个对象中
修改该成员变量会影响到另一个对象 的该成
员变量值
-
前面我们克隆羊就是浅拷贝
-
浅拷贝是使用默认的 clone()方法来实现
2
3
2
3
现在羊有它的朋友，克隆羊的话，它的朋友是被复制一份呢，还是指向原来的引用呢？
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
2/**
3 * @author 孙一鸣 on 2020/2/6
4 */
5public class Client {
6
7 public static void main(String[] args) {
8 Sheep sheep =new Sheep("tom",1,"白色");
9 sheep.friend=new Sheep("jack",1,"黑色");
10 //现在羊有它的朋友，克隆羊的话，它的朋友是被复制一份呢，还是指向原来的引用呢？
11
12 Sheep sheep1 =(Sheep)sheep.clone();
13 Sheep sheep2 =(Sheep)sheep.clone();
14 Sheep sheep3 =(Sheep)sheep.clone();
15
16
17 System.out.println(sheep1.friend.hashCode());
18 System.out.println(sheep2.friend.hashCode());
19 System.out.println(sheep3.friend.hashCode());
20 }
21}
22
23
24
结果分析:
深拷贝基本介绍
、
- 复制对象的所有基本数据类型的成员变量值
- 为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变
量所引用的对象，直到该对象可达的所有对象。也就是说，
对象进行深拷贝要对
整个对象进行拷贝
- 深拷贝实现方式1：重写clone方法来实现深拷贝
- 深拷贝实现方式2：通过对象序列化实现深拷贝(
推荐)
全部复制，然后各自独立。你修改克隆对象对于原型对象没有丝毫影响，完全的影分身！
重写clone方法来实现深拷贝
案例说明:
大圣 要制作分身 ，每一个分身有名字 和自己的武器，武器有着自己的高度和重量，每一个大圣要有自己独立思想。
代码实现：
大圣类：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
2
3import java.io.Serializable;
4
5/**
6 * 齐天大圣 孙悟空 分身术
7 * 深拷贝就是将孙悟空化为无数分身，每一个分身都不相同
8 *
9 * @author 孙一鸣 on 2020/2/6
10 */
11public class DaSheng implements Serializable, Cloneable {
12 public String name;
13 //齐天大圣的武器
14 public Wuqi wuqi;
15
16 //方法一：重写clone
17 @Override
18 protected Object clone() throws CloneNotSupportedException {
19 Object deep = null;
20 //这里完成对基本数据类型（属性）and String 的克隆
21 deep = super.clone();
22 //对引用类型的属性进行单独处理
23
24
25 // 首先，将已经处理好基本类型的deep，由 Object类型 转换为 DeepProtoType 类型
26
27 DaSheng sunWuKong = (DaSheng) deep;
28 //此时的deep 处理好的内容 有 name属性 ，
29
30 //将deep转为 DaSheng ，name属性已被复制，没有处理的有 孙悟空的金箍棒
31
32 //单独复制孙悟空的金箍棒
33 sunWuKong.wuqi = (Wuqi) wuqi.clone();
34
35 return sunWuKong;
36 }
37}
38
39
40
武器类：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
2
3import java.io.Serializable;
4
5/**
6 * @author 孙一鸣 on 2020/2/6
7 */
8public class Wuqi implements Cloneable, Serializable {
9 private static final long serialVersionUID=1L;
10
11 //金箍棒的高度
12 public String wuqi_hight;
13
14 //金箍棒的重量
15 public String wuqi_weight;
16
17 public Wuqi(String wuqi_hight, String wuqi_weight) {
18 this.wuqi_hight = wuqi_hight;
19 this.wuqi_weight = wuqi_weight;
20 }
21
22 @Override
23 protected Object clone() throws CloneNotSupportedException {
24 return super.clone();
25 }
26}
27
28
29
测试类：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
2
3
4/**
5 * @author 孙一鸣 on 2020/2/6
6 */
7public class Client {
8
9 public static void main(String[] args) throws Exception{
10
11 DaSheng monkey =new DaSheng();
12 monkey.name="孙悟空";
13 monkey.wuqi = new Wuqi("100","100");
14 System.out.println(monkey+"武器高："+monkey.wuqi.wuqi_hight +" 武器重： "+monkey.wuqi.wuqi_weight);
15 System.out.println("深拷贝..");
16 DaSheng monkey2= (DaSheng) monkey.clone();
17 DaSheng monkey3= (DaSheng) monkey.clone();
18 System.out.println(monkey2.hashCode() == monkey3.hashCode());
19 }
20}
21
22
23
对象序列化方式深拷贝
这个时候要聊一聊什么是序列化了。
把对象写到流里的过程是序列化(Serialization)过程；而把对象从流中读出来的过程则叫反序列化(Deserialization)过程。应当指出的是，写到流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。
简单的讲就是序列化就将对象写到流的一个过程，写到流里面去（就是字节流）就等于复制了对象，但是原来的对象并没有动，只是复制将类型通过流的方式进行读取，然后写到另个内存地址中去！
大圣类:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
2
3import java.io.*;
4
5/**
6 * 齐天大圣 孙悟空 分身术
7 * 深拷贝就是将孙悟空化为无数分身，每一个分身都不相同
8 *
9 * @author 孙一鸣 on 2020/2/6
10 */
11public class DaSheng implements Serializable, Cloneable {
12 public String name;
13 //齐天大圣的武器
14 public Wuqi wuqi;
15
16 //深拷贝 方式2 通过对象的序列化实现
17 public Object FenShen() {
18 //创建流对象
19 ByteArrayOutputStream bos = null;
20 ObjectOutputStream oos = null;
21 ByteArrayInputStream bis = null;
22 ObjectInputStream ois = null;
23
24 try {
25 //序列化
26 bos = new ByteArrayOutputStream();
27 oos = new ObjectOutputStream(bos);
28
29 //将当前对象以对象流的方式输出
30 oos.writeObject(this);
31
32 //反序列化
33 bis = new ByteArrayInputStream(bos.toByteArray());
34 ois = new ObjectInputStream(bis);
35
36 DaSheng daSheng = (DaSheng) ois.readObject();
37 return daSheng;
38 } catch (Exception e) {
39 return null;
40 } finally {
41 try {
42 bos.close();
43 oos.close();
44 bis.close();
45 ois.close();
46 } catch (Exception e) {
47
48 }
49 }
50
51
52 }
53}
54
55
56
武器类没有变化：
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
2
3import java.io.Serializable;
4
5/**
6 * @author 孙一鸣 on 2020/2/6
7 */
8public class Wuqi implements Cloneable, Serializable {
9 private static final long serialVersionUID=1L;
10
11 //金箍棒的高度
12 public String wuqi_hight;
13
14 //金箍棒的重量
15 public String wuqi_weight;
16
17 public Wuqi(String wuqi_hight, String wuqi_weight) {
18 this.wuqi_hight = wuqi_hight;
19 this.wuqi_weight = wuqi_weight;
20 }
21
22 @Override
23 protected Object clone() throws CloneNotSupportedException {
24 return super.clone();
25 }
26}
27
28
29
小结
原型模式的注意事项和细节
优点
- 创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提
高效率
- 不用重新初始化对象，而是动态地获得对象运行时的状态
- 如果原始对象发生变化(增加或者减少属性)，其它克隆对象的也会发生相应的变化，
无需修改代码
- 在实现深克隆的时候可能需要比较复杂的代码
缺点：
需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有
的类进行改造时，需要修改其源代码，
违背了ocp原则
原型模式适用场景
在以下情况可以考虑使用。
1创建对象成本比较大，比如初始化要很长时间的，占用太多CPU的，新对象可以通过复制已有的对象获得的，如果是相似的对象，则可以对其成员变量稍作修改。
2系统要保存对象状态的，而对象的状态改变很小。
3需要避免使用分层次的工厂类来创建分层次的对象，并且类的对象就只用一个或很少的组合状态！
