浅克隆与深克隆

继上篇原型模式，这里讲一下原型模式中的浅克隆与深克隆 

浅克隆 

对于对象中的引用类型，他只复制了引用对象的内存地址，复制的不是他的值。

下面我们看一个具体的原型模式类的写法，在ConcretePrototype 原型类中，添加List引用类型。

public class ConcretePrototype implements Cloneable {
	private int age;
	private String name;
	private List<String> course ;//引用类型，模拟浅克隆
	
	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	public List<String> getList() {
		return course;
	}

	public void setList(List<String> course) {
		this.course = course;
	}

	// 实现Cloneable,JDK自带克隆
	public ConcretePrototype clone() {
		ConcretePrototype obj = null;
		try {
			obj = (ConcretePrototype)super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return obj;
	}
	
	// 打印信息
	public String toString() {
		return "obj:{age=" + age +",name=" + name + ",course=" + course + "}";
	}
}

测试类，在克降新的对象出来后，继续给list赋值；结果两个对象打印出来的结果是一样的，这个就是因为浅克隆并没有复制引用类型的值，只是复制了他的内存地址。

public class Test2 {
	public static void main(String[] args) {
		ConcretePrototype prototype = new ConcretePrototype();
		prototype.setAge(12);
		prototype.setName("张三");
		List<String> course =  new ArrayList<String>();//学习课程
		course.add("JAVA");
		prototype.setList(course);
		
		//克隆，拷贝,添加类型
		ConcretePrototype cloneType = prototype.clone();
		course.add("C#");//给list添加新值
		
		// 打印输出
		System.out.println("原型对象：" + prototype);
		System.out.println("克隆对象：" + cloneType);
		System.out.println( prototype.getList() == cloneType.getList());
	}
}

输出结果，打印信息一致，说明两者还不是独立的对象。

深度克隆

采用序列化进行深度克隆，不仅克隆出两个独立的对象，并且对引用类型的值也做了复制。

在上面ConcretePrototype类的基础上我们继续改造，来看代码，增加一个deepClone()方法:

// 序列化，实现深度克隆
	public ConcretePrototype deepClone() {
		ConcretePrototype obj = null;
		try {
			ByteArrayOutputStream bos = new ByteArrayOutputStream();
			ObjectOutputStream oos = new ObjectOutputStream(bos);
			oos.writeObject(this);

			ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
			ObjectInputStream ois = new ObjectInputStream(bis);
			return (ConcretePrototype) ois.readObject();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return obj;
	}

测试类，克隆对象给list添加了值，在输出位置判断两个对象的打印信息。

public class Test3 {
	public static void main(String[] args) {
		ConcretePrototype prototype = new ConcretePrototype();
		prototype.setAge(12);
		prototype.setName("张三");
		List<String> course =  new ArrayList<String>();//学习课程
		course.add("JAVA");
		prototype.setList(course);
		
		//克隆，拷贝,添加类型
		ConcretePrototype cloneType = prototype.deepClone();
		cloneType.getList().add("C#");//给克隆对像list添加新值
		
		// 打印输出
		System.out.println("原型对象：" + prototype);
		System.out.println("克隆对象：" + cloneType);
		System.out.println( prototype == cloneType);
		System.out.println( prototype.getList() == cloneType.getList());
	}
}

输出结果，引用类型list的值进行了复制，创建了两个独立的对象。

克隆破坏单例模式

如果我们克隆的目标的对象是单例对象，那意味着，深克隆就会破坏单例。实际上防止克隆破坏单例解决思路非常简单，禁止深克隆便可。要么你我们的单例类不实现Cloneable接口;要么我们重写clone()方法，在clone方法中返回单例对象即可。

原型模式的优缺点

优点:

1、性能优良，Java自带的原型模式是基于内存二进制流的拷贝，比直接new一个对象性能上提升了许多。

2、可以使用深克隆方式保存对象的状态，使用原型模式将对象复制一份并将其状态保存起来，简化了创建对象的过程，以便在需要的时候使用(例如恢复到历史某一状态)，可辅助实现撤销操作。

缺点:

1、需要为每一个类配置一个克隆方法。

2、克隆方法位于类的内部，当对已有类进行改造的时候，需要修改代码，违反了开闭原则。

3、在实现深克隆时需要编写较为复杂的代码，而且当对象之间存在多重嵌套引用时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现起来会比较麻烦。