简介

例如：现在有一只羊 tom，姓名为: tom, 年龄为：1，颜色为：白色，请编写程序创建和 tom 羊属性完全相同的 10 只羊。

传统方式

代码案例

/**
 * 羊
 */
@Data
@ToString
@AllArgsConstructor
public class Sheep {
	private String name;
	private int age;
	private String color;
}

/**
 *	直接创建10个对象
 */
public class Client {
	public static void main(String[] args) {

		// 传统的方法
		Sheep sheep = new Sheep("tom", 1, "白色");

		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());
		// ....

		System.out.println(sheep);
		System.out.println(sheep2);
		System.out.println(sheep3);
		System.out.println(sheep4);
		System.out.println(sheep5);
		// ...

	}
}

优缺点问题

• 优点
  • 比较好理解，简单易操作
• 缺点
  • 在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较低
  • 总是需要重新初始化对象，而不是动态地获得对象运行时的状态，不够灵活
• 改进的思路分析
  • Java 中 Object 类是所有类的根类，Object 类提供了一个 clone () 方法，该方法可以将一个 Java 对象复制一份，但是需要实现 clone 的 Java 类必须要实现一个接口 Cloneable， 该接口表示该类能够复制且具有复制的能力 (原型模式)

原型模式

原型模式 (Prototype 模式) 是指：

▷ 用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象

▷ 原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象， 无需知道如何创建的细节

工作原理是：通过将一个原型对象传给那个要发动创建的对象，这个要发动创建 的对象通过请求原型对象拷贝它们自己来实施创建，即对象.clone ()

代码案例

/**
 * 羊
 */
@Data
@ToString
public class Sheep implements Cloneable {
	private String name;
	private int age;
	private String color;
	private Sheep friend;

	public Sheep(String name, int age, String color) {
		super();
		this.name = name;
		this.age = age;
		this.color = color;
	}

	/**
	 * 使用默认的clone方法来实现
	 */
	@Override
	protected Sheep clone() throws CloneNotSupportedException {
		Sheep sheep = null;
		try {
			sheep = (Sheep) super.clone();
		} catch (Exception e) {
			e.printStackTrace();
		}
		return sheep;
	}
}

public class Client {
	public static void main(String[] args) throws CloneNotSupportedException {

		System.out.println("原型模式完成对象的创建");
		Sheep sheep = new Sheep("tom", 1, "白色");

		sheep.setFriend(new Sheep("jack", 2, "黑色"));

		Sheep sheep2 = sheep.clone(); // 克隆
		Sheep sheep3 = sheep.clone(); // 克隆
		Sheep sheep4 = sheep.clone(); // 克隆
		Sheep sheep5 = sheep.clone(); // 克隆

		// friend并没有克隆，引用地址还是同一个
		System.out.println("sheep2 =" + sheep2 + "sheep2.friend=" + sheep2.getFriend().hashCode());
		System.out.println("sheep3 =" + sheep3 + "sheep3.friend=" + sheep3.getFriend().hashCode());
		System.out.println("sheep4 =" + sheep4 + "sheep4.friend=" + sheep4.getFriend().hashCode());
		System.out.println("sheep5 =" + sheep5 + "sheep5.friend=" + sheep5.getFriend().hashCode());

	}
}

问题说明

对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。

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

前面我们克隆羊就是浅拷贝。

深拷贝

复制对象的所有基本数据类型的成员变量值。

为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象。也就是说，对象进行深拷贝要对整个对象进行拷贝。

深拷贝实现方式 1：重写 clone 方法来实现深拷贝。

深拷贝实现方式 2：通过对象序列化实现深拷贝 (推荐)。

代码案例

/**
 * 深度克隆目标对象
 */
@AllArgsConstructor
public class DeepCloneableTarget implements Serializable, Cloneable {

	private static final long serialVersionUID = 8800114104308318541L;
	private String cloneName;
	private String cloneClass;

	/**
	 * 因为这个类的属性都是String,所以可以直接调用super的clone方法
	 */
	@Override
	protected DeepCloneableTarget clone() throws CloneNotSupportedException {
		return (DeepCloneableTarget) super.clone();
	}

}

@NoArgsConstructor
public class DeepProtoType implements Serializable, Cloneable {

	private static final long serialVersionUID = 4311988580279915115L;

	public String name; // String 属性
	public DeepCloneableTarget deepCloneableTarget;// 引用类型

	/**
	 * 深拷贝 - 方式 1 使用clone 方法
	 */
	@Override
	protected DeepProtoType clone() throws CloneNotSupportedException {
		// 先对基本属性的克隆
		DeepProtoType deepProtoType = (DeepProtoType) super.clone();
		// 再对引用类型克隆
		deepProtoType.deepCloneableTarget = deepCloneableTarget.clone();
		return deepProtoType;
	}

	/**
	 * 方式 2 采用对象的序列化实现 (推荐)
	 * @return
	 */
	protected DeepProtoType streamClone() {
		DeepProtoType copyObj = null;
		ByteArrayOutputStream bos = null;
		ByteArrayInputStream bis = null;
		ObjectOutputStream oos = null;
		ObjectInputStream ois = null;
		try {
			bos = new ByteArrayOutputStream();
			// 序列化
			oos = new ObjectOutputStream(bos);
			oos.writeObject(this);// 当前这个对象以对象流的方式输出
			// 反序列化
			bis = new ByteArrayInputStream(bos.toByteArray());
			ois = new ObjectInputStream(bis);
			copyObj = (DeepProtoType) ois.readObject();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally {
			try {
				bos.close();
				oos.close();
				bis.close();
				ois.close();
			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}

		return copyObj;
	}
}

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());

		// 方式2 完成深拷贝
		DeepProtoType p2 = (DeepProtoType) p.streamClone();

		System.out.println("p.name=" + p.name + "p.deepCloneableTarget=" + p.deepCloneableTarget.hashCode());
		System.out.println("p2.name=" + p2.name + "p2.deepCloneableTarget=" + p2.deepCloneableTarget.hashCode());

	}
}