设计模式之路 | 原型模式_原型模式思路的系统-CSDN博客

本文链接：https://blog.csdn.net/Willson_L/article/details/103474122

原型模式的定义与特点

原型（Prototype）模式的定义如下：用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。例如，Windows 操作系统的安装通常较耗时，如果复制就快了很多。在生活中复制的例子非常多，这里不一一列举了。

原型模式的结构与实现

由于 Java 提供了对象的 clone() 方法，所以用 Java 实现原型模式很简单。

1. 模式的结构

原型模式包含以下主要角色。

抽象原型类：规定了具体原型对象必须实现的接口。
具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。
访问类：使用具体原型类中的 clone() 方法来复制新的对象。

原型模式的结构图

public class Sheep implements Cloneable {

	private String name;
	private Integer age;
	private String color;
	
	private Sheep friend;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Integer getAge() {
		return age;
	}

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

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}
	
	public Sheep getFriend() {
		return friend;
	}

	public void setFriend(Sheep friend) {
		this.friend = friend;
	}

	@Override
	protected Object clone() {
		Sheep s = null;
		try {
			s = (Sheep) super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return s;
	}

	@Override
	public String toString() {
		return "Sheep [name=" + name + ", age=" + age + ", color=" + color + ", friend=" + friend.hashCode() + "]";
	}
}

public class PrototypeDemo {

	public static void main(String[] args) {
		Sheep sheep1 = new Sheep();
		sheep1.setName("sheep01");
		sheep1.setAge(10);
		sheep1.setColor("黄色");
		
		Sheep sheep2 = new Sheep();
		sheep2.setName("sheep02");
		sheep2.setAge(15);
		sheep2.setColor("白色");
		sheep2.setFriend(sheep1);
		
		Object clone = sheep2.clone();
		
		System.out.println(sheep2);
		System.out.println(clone);
	}
}

深拷贝

有上述输入的值可以看出，拷贝后的 friend 对象的hashCode 相等，所以friend是同一个对象。因此，可以确定通过 super.clone() 的对象是钱拷贝的对象。

浅拷贝介绍

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

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

深拷贝介绍

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

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

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

4. 深拷贝实现方式2：通过对象序列化来实现深拷贝

第一种方式：重写clone方法来实现深拷贝

public class Sheep implements Cloneable, Serializable {

	private static final long serialVersionUID = 2795877779132802842L;
	
	private String name;
	private Integer age;
	private String color;
	
	private Sheep friend;

        // 省略 getter 和 setter 方法

	@Override
	protected Object clone() {
		Sheep s = null;
		try {
			s = (Sheep) super.clone();
			if (s.getFriend() != null) {
				Sheep friend = (Sheep) s.getFriend().clone();
				s.friend = friend;
			}
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return s;
	}

	@Override
	public String toString() {
		return "Sheep [name=" + name + ", age=" + age + ", color=" + color + ", friend=" + friend.hashCode() + "]";
	}
}

第二种方式：通过对象序列化来实现深拷贝

public class Sheep implements Cloneable, Serializable {

	private static final long serialVersionUID = 2795877779132802842L;
	
	private String name;
	private Integer age;
	private String color;
	
	private Sheep friend;

        // 此处省略 getter 和 setter

	@Override
	protected Object clone() {
		ByteArrayOutputStream baos = null;
		ObjectOutputStream oos = null;
		ByteArrayInputStream bais = null;
		ObjectInputStream ois = null;
		Sheep s = null;
		try {
			// 序列化
			baos = new ByteArrayOutputStream();
			oos = new ObjectOutputStream(baos);
			// 当前这个对象以对象流的方式输出
			oos.writeObject(this);
			
			// 反序列化
			bais = new ByteArrayInputStream(baos.toByteArray());
			ois = new ObjectInputStream(bais);
			s = (Sheep) ois.readObject();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			// close流，此处省略
		}
		return s;
	}

	@Override
	public String toString() {
		return "Sheep [name=" + name + ", age=" + age + ", color=" + color + ", friend=" + friend.hashCode() + "]";
	}
}