## **1. 定义**
>**原型模式(Prototype Pattern)**：使用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
简单地说：相信大多数的人都看过《西游记》，对孙悟空拔毛变出小猴子的故事情节应该都很熟悉。孙悟空可以用猴毛根据自己的形象复制出很多跟自己一模一样的小猴兵出来，其实在设计模式中也有一个类似的模式，我们可以通过一个原型对象来克隆出多个一模一样的对象，这个模式就是原型模式。
## **2. 场景**
>M公司一直在使用自行开发的一个OA系统进行日常工作办理，但在使用过程中，越来越多的人对工作周报的创建和编写模块产生了抱怨。追其原因，M公司的OA管理员发现，由于某些岗位每周工作存在重复性，工作周报内容都大同小异，如下图所示：
>这些周报只有一些小地方存在差异，但是现行系统每周默认创建的周报都是空白报表，因此用户只能通过重新输入或不断地复制与粘贴来填写重复的周报内容，极大地降低了工作效率，浪费宝贵的时间。如何快速创建相同或者相似的工作周报，成为了M公司软件开发人员的一个新问题。
M公司开发人员经过分析，决定按照以下思路对工作周报模块进行重新设计：
（1）除了允许用户创建新周报外，还允许用户将创建好的周报保存为模板（也就是原型）。
（2）用户在再次创建周报时，可以创建全新的周报，还可以选择合适的模板复制生成一个相同的周报，然后对新生成的周报根据实际情况进行修改，产生新的周报。
`需要注意的是，通过克隆方法所创建的对象时全新的对象。`
>原型模式中的角色包括:
● Prototype（抽象原型类）：它是声明克隆方法的接口，是所有具体原型类的公共父类，可以是抽象类也可以是接口，甚至还可以是具体实现类。
● ConcretePrototype（具体原型类)：它实现在抽象原型类中声明的克隆方法，在克隆方法中返回自己的一个克隆对象
● Client（客户类）：**让一个原型对象克隆自身从而创建一个新的对象，在客户类中只需要**直接实例化或通过工厂方法等方式创建一个原型对象**，再通过**调用该对象的克隆方法即可得到多个相同的对象**。由于客户类针对抽象原型类Prototype编程，因此用户可以根据需要选择具体原型类，系统具有较好的可扩展性，增加或更换具体原型类都很方便。
`结构图图下:`
## **3. 代码实现**
以克隆羊为例：传统的解决方式
```
public class Sheep {
private String name;
private int age;
private String color;
public Sheep(String name, int age, String color) {
this.name = name;
this.age = age;
this.color = color;
}
public String getName() {return name; }
public void setName(String name) {this.name = name; }
public int getAge() {return age; }
public void setAge(int age) {this.age = age; }
public String getColor() {return color; }
public void setColor(String color) { this.color = color; }
@Override
public String toString() {
return "Sheep{" +
"name='" + name + '\'' +
", age=" + age +
", color='" + color + '\'' +
'}';
}
}
```
```
public class Client {
public static void main(String[] args) {
Sheep sheep = new Sheep("tom", 1, "white");
Sheep sheep1 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
Sheep sheep2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
Sheep sheep3 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
Sheep sheep4 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
Sheep sheep5 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
}
}
```
>1）在创建对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较低。
2）总是需要重新初始化对象，而不是动态地获取对象的运行状态
**浅拷贝思路：** Java的Object类提供了一个clone()方法，该方法可以将一个java对象复制一份，但是需要事先clone的java类必须要事先一个接口Cloneable。
**基本介绍：**
1）原型模式是指：用原型实例指定创建对象的种类，并且通过拷贝原型 创建对象。
2）是一种创建型设计模式，允许一个对象再创建一个可定制的对象，无需知道如何创建的细节。
对于数据类型是基本数据类型的成员变量，浅拷贝直接进行值传递，引用型数据类型，会将成员变量的引用值复制一份给新的对象。
```
public class Sheep implements Cloneable {
private String name;
private int age;
private String color;
private String address="蒙古羊";
public Sheep friend;
public Sheep(String name, int age, String color) {
this.name = name;
this.age = age;
this.color = color;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
@Override
public String toString() {
return "Sheep{" +
"name='" + name + '\'' +
", age=" + age +
", color='" + color + '\'' +
", address='" + address + '\'' +
'}';
}
//克隆该实例，使用默认的clone方法完成
@Override
protected Object clone() {
Sheep sheep = null;
try {
sheep = (Sheep) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return sheep;
}
}
```
```
public class Client {
public static void main(String[] args) {
Sheep sheep = new Sheep("tom", 1, "white");
sheep.friend=new Sheep("jack",2,"black");//加入引用型对象属性
Sheep clone = (Sheep) sheep.clone();
Sheep clone2 = (Sheep) sheep.clone();
Sheep clone3 = (Sheep) sheep.clone();
Sheep clone4 = (Sheep) sheep.clone();
Sheep clone5 = (Sheep) sheep.clone();
System.out.println(clone2+"clone2"+clone2.friend.hashCode());
System.out.println(clone3+"clone3"+clone3.friend.hashCode());//hashcode值一样
System.out.println(clone==clone2);//false
}
}
```
>**深拷贝：**
1）复制对象的基本数据类型的成员变量值
2）为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量锁引用的对象，直到该对象所达的所有对象。即 对象进行深拷贝就是对整个对象（包括对象的引用类型）进行拷贝。
`方式1：重写clone方法实现深拷贝`
`方式2：通过对象序列化实现深拷贝`
```
public class DeepCloneableTarget implements Serializable, Cloneable {
private static final long serialVersionUID = 1L;
private String cloneName;
private String cloneClass;
public DeepCloneableTarget(String cloneName, String cloneClass) {
this.cloneName = cloneName;
this.cloneClass = cloneClass;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
```
```
public class DeepProtoType implements Serializable, Cloneable{
public String name;
public DeepCloneableTarget deepCloneableTarget;
public DeepProtoType() {
super();
}
//方式一：深拷贝 使用clone方法
@Override
protected Object clone() throws CloneNotSupportedException {
Object deep = null;
deep = super.clone();//对象的深拷贝
//强转成哪种类的对象，就是哪种类要实现Serializable, Cloneable接口进行深拷贝
DeepProtoType deepProtoType = (DeepProtoType)deep;//类型强转
deepProtoType.deepCloneableTarget = (DeepCloneableTarget)deepCloneableTarget.clone();//对象的引用类型的深拷贝
return deepProtoType;
}
// 方式二： 通过对象的序列化 实现深拷贝 （推荐）
public Object deepClone() {
//创建流对象
ByteArrayOutputStream bos = null;
ObjectOutputStream oos = null;
ByteArrayInputStream bis = null;
ObjectInputStream ois = null;
try {
//序列化
bos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(bos);
oos.writeObject(this);//当前这个对象以对象流的方式输出
//反序列化
bis = new ByteArrayInputStream(bos.toByteArray());
ois = new ObjectInputStream(bis);
DeepProtoType copyObj = (DeepProtoType)ois.readObject();
return copyObj;
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
try {
bos.close();
oos.close();
bis.close();
ois.close();
} catch (Exception e2) {
System.out.println(e2.getMessage());
}
}
}
}
```
```
public class Client {
public static void main(String[] args) throws Exception {
DeepProtoType p = new DeepProtoType();
p.name = "宋江";
p.deepCloneableTarget = new DeepCloneableTarget("大牛", "大牛的类");
//方式1：深拷贝
DeepProtoType p2 = (DeepProtoType) p.clone();
System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
System.out.println("p2.name=" + p2.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
// DeepProtoType p2 = (DeepProtoType) p.deepClone();
//
// System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
// System.out.println("p2.name=" + p.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());
}
}
```
- 前言
- 第一章 设计七大原则
- 第1节 开闭原则
- 第2节 依赖倒置原则
- 第3节 单一职责原则
- 第4节 接口隔离原则
- 第5节 迪米特法则
- 第6节 里氏替换原则
- 第7节 合成复用原则
- 第二章 简单工厂模式
- 第1节 使用场景
- 第2节 示例代码
- 第三章 创建者模式
- 第1节 工厂方法模式
- 第2节 抽象工厂模式
- 第3节 建造者模式
- 第4节 原型模式
- 第5节 单例模式
- 第四章 结构型模式
- 第1节 适配器模式
- 第2节 桥接模式
- 第3节 组合模式
- 第4节 装饰者模式
- 第5节 外观模式
- 第6节 享元模式
- 第7节 代理模式
- 第五章 行为模式
- 第1节 责任链模式
- 第2节 命令模式
- 第3节 迭代器模式
- 第4节 中介者模式
- 第5节 备忘录模式
- 第6节 观察者模式
- 第7节 状态模式
- 第8节 策略模式
- 第9节 模板方法模式
- 第10节 访问者模式
- 第11节 解释器模式