设计模式，不管是在准备面试过程，还是在实际工作编码中，都是应该掌握的技能，所以特别整理一下设计模式相关的知识，希望对大家有所帮助
可能我们会遇到这样一种场景：在编码中有这样一个对象，此对象比较重（构造比较耗时）或者是构造方法相当复杂，使用起来很麻烦，总之创建成本很高，类似这样
public class HeavyObject {
public HeavyObject(){
try {
// 模拟次对象创建耗时
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("HeavyObject init success");
}
}
而这种对象可能由于业务的需求，需要在循环中创建并使用
public class PrototypeTest {
public static void main(String[] args) {
long l1 = System.currentTimeMillis();
for(int i = 0; i < 10; i ++) {
HeavyObject heavyObject = new HeavyObject();
System.out.println(heavyObject);
}
long l2 = System.currentTimeMillis();
System.out.println(l1 - l2);
}
}
上面这段代码的效率相信不用执行大家也知道是多大惨不忍睹，执行测试，在我机器上为：10006ms；而针对这种情况能不能有一个好的方式来优化呢？当然是今天的主角：原型模式啦。虽然号称是“设计模式”，但是原型模式在实现的角度看确实很简单：实现Cloneable接口即可，然后再获取新的对象实例的时候使用原实例对象的clone()即可；
HeavyObject 变化为
public class HeavyObject implements Cloneable {
public HeavyObject(){
try {
// 模拟次对象创建耗时
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("HeavyObject init success");
}
}
测试方法
public class PrototypeTest {
public static void main(String[] args) throws CloneNotSupportedException {
long l1 = System.currentTimeMillis();
HeavyObject heavyObject = new HeavyObject();
for(int i = 0; i < 10; i ++) {
// 通过clone获取新的对象
HeavyObject cloneHeavyObject = (HeavyObject) heavyObject.clone();
System.out.println(cloneHeavyObject);
}
long l2 = System.currentTimeMillis();
System.out.println(l1 - l2);
}
}
此时测试结果为1000ms，耗时主要在为初次构造HeavyObject 实例时构造方法耗费，而且结果中，只打印了一次HeavyObject 构造方法中的"HeavyObject init success"可以印证这一点，可见使用clone创建对象实例时没有调用构造方法，实际上是通过二进制流的方式只能读取源数据并生成新的对象（Object中的native方法）；
原型模式创建实例的方式看起来简单而美好，但是有时候也是有些小坑的。比如我们的HeavyObject 中有List成员变量
public class HeavyObject implements Cloneable {
List list;
public List getList() {
return list;
}
public void setList(List list) {
this.list = list;
}
// ... 省略重复代码
而我们使用的业务场景是这样的
public class PrototypeTest {
public static void main(String[] args) throws CloneNotSupportedException {
HeavyObject heavyObject = new HeavyObject();
List list = new ArrayList();
list.add(1);
heavyObject.setList(list);
// 通过clone拷贝对象
HeavyObject cloneHeavyObject = (HeavyObject) heavyObject.clone();
// 模拟业务场景，对clone的对象中的list进行操作
cloneHeavyObject.getList().remove(0);
System.out.println(heavyObject.getList());
}
执行结果
HeavyObject init success
[]
Process finished with exit code 0
可见，对clone对象成员变量进行操作，影响了原对象。我们在最后一行打断点，看一下
上面的原对象和下面的clone对象的成员变量list，指向的对象都是ArrayList@455，所以造成操作clone对象的List而影响了原对象，这种拷贝对象的方式，也被成为浅拷贝，浅拷贝就是将原对象直接拷贝一份，原对象中的成员变量的指针当然也拷贝过来，所以该例中的两个对象的list仍旧指向同一个对象；怎么解决呢？其实jdk早给给我们了答案，我们翻看一下ArrayList，发现它也实现了Cloneable接口的，然后看下其clone()
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}
ArrayList答题实现思路是将ArrayList本身拷贝后，将其成员变量elementData ，通过Arrays方法重写拷贝一份赋值，我们尝试把HeavyObject的clone()这么改，即新创建一个List对象
@Override
protected Object clone() throws CloneNotSupportedException {
HeavyObject cloneHeavyObject = (HeavyObject) super.clone();
cloneHeavyObject.list = new ArrayList(this.list);
return cloneHeavyObject;
}
在执行测试方法结果
HeavyObject init success
[1]
Process finished with exit code 0
上面这种，除了拷贝对象本身以为，还将对象中其他对象也拷贝一份新的对象，也就是我们常说的深拷贝。其实上例实现的深拷贝，也是有问题的，比如List承载的元素依旧是引用类型，而我的拷贝方式是直接将原List中的对象拿过来加到新的List中，所以虽然List对象是新创建的，但其中元素依旧指向同一个对象，所以业务有需求时应继续给List中对象也继续拷贝一份新的。
