设计模式 - 原型模式

1. 原型模式概述

原型模式指的是用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象，允许一个对象再创建另外一个可定制的对象而无需知道如何创建的细节。

2. 原型模式类图

1. Prototype : 原型类，声明一个克隆自己的接口。
2. ConcretePrototype: 具体的原型类 , 实现一个克隆自己的操作。
3. Client: 让一个原型对象克隆自己，从而创建一个新的对象属性一样。

3. 核心代码

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) {
		super();
		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 (Exception e) {
			// TODO: handle exception
			System.out.println(e.getMessage());
		}
		// TODO Auto-generated method stub
		return sheep;
	}

}

4. 关于浅拷贝和深拷贝

因为原型模式涉及到了深拷贝和浅拷贝，所以小结一下关于我对这方面的理解。

4.1 浅拷贝

简单来说，浅拷贝会直接进行值传递，也就是将属性值复制一份给新的对象。
对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。
值得注意的是，因为实际上两个对象的该成员变量都指向同一个实例，在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。

4.2 深拷贝

简单来说，深拷贝会复制对象的所有基本数据类型的成员变量值。
深拷贝会为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象。
也就是说，对象进行深拷贝要对整个对象进行拷贝。

1. 重写clone方法实现深拷贝。

@Override
	protected Object clone() throws CloneNotSupportedException {
		Object deep = null;
		// 这里完成对基本数据类型(属性)和String的克隆
		deep = super.clone();
		// 对引用类型的属性，进行单独处理
		DeepProtoType deepProtoType = (DeepProtoType) deep;
		deepProtoType.deepCloneableTarget = (DeepCloneableTarget) deepCloneableTarget.clone();
		return deepProtoType;
	}

2. 对象序列化实现深拷贝。

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) {
			// TODO: handle exception
			e.printStackTrace();
			return null;
		} finally {
			// 关闭流
			try {
				bos.close();
				oos.close();
				bis.close();
				ois.close();
			} catch (Exception e2) {
				// TODO: handle exception
				System.out.println(e2.getMessage());
			}
		}
	}

5. 使用场景总结

1. 创建新的对象比较复杂时，可以利用原型模式简化创建的过程。
2. 如果原始对象发生了变化，比如增加或减少了属性，那么其他clone的对象也会发生相应的变化而不需要改代码。
3. 值得注意的是，需要为每一个全新的类配置一个clone方法，但对已存在的类进行改造时，就违背了OCP原则了。

附：

1. 完整代码：尚硅谷图解Java设计模式资料下载。