java 设计模式之原型模式(浅复制深复制)

概念：

原形模式：

原型模式是一种创建型设计模式,它通过复制一个已经存在的实例来返回新的实例,而不是新建实例.被复制的实例就是我们所称的原型,这个原型是可定制的.
原型模式多用于创建复杂的或者耗时的实例, 因为这种情况下,复制一个已经存在的实例可以使程序运行更高效,或者创建值相等,只是命名不一样的同类数据.

原型模式中的拷贝分为"浅拷贝"和"深拷贝":
浅拷贝: 对值类型的成员变量进行值的复制,对引用类型的成员变量只复制引用,不复制引用的对象.
深拷贝: 对值类型的成员变量进行值的复制,对引用类型的成员变量也进行引用对象的复制.

演示：

package com.dairuijie.prototype;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * 原型模式虽然是创建型的模式，但是与工程模式没有关系，从名字即可看出，该模式的思想就是将一个
对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对。在 Java 中，复制对象是通过 clone()实现的
实现深复制需要实现Serializable 可以序列化 不然没法序列化对象去进行流的输入输出
 * @author DRJYY
 *
 */
public class Prototype implements   Cloneable,Serializable{

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private Integer age;
	private String name;
	
	public Integer getAge() {
		return age;
	}

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

	public String getName() {
		return name;
	}

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

	/**
	 * 浅复制
	 */
	@Override
	protected Object clone() throws CloneNotSupportedException {
	/*	Prototype prot = (Prototype) super.clone();
		return prot;*/
		return super.clone();
	}
	
	/**
	 * 深复制
	 * @return
	 * @throws IOException
	 * @throws ClassNotFoundException
	 */
	public Object deepClone() throws IOException, ClassNotFoundException{
		/**
		 *  写入当前对象的二进制流
		 */
		ByteArrayOutputStream bos =  new ByteArrayOutputStream();
		ObjectOutputStream oos =  new ObjectOutputStream(bos);
		oos.writeObject( this );
		
		/**
		 * 写出当前对象二进制流
		 */
		ByteArrayInputStream bis =  new ByteArrayInputStream(bos.toByteArray());
		ObjectInputStream ois;
		ois = new ObjectInputStream(bis);
		return ois.readObject();
	}

	public Prototype(Integer age, String name) {
		this.age = age;
		this.name = name;
	}
	
}

package com.dairuijie.prototype;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
/**
 * 学生实体类 除了基本数据类型 同时包括Prototype 引用 方便我们测试结果
 * @author DRJYY
 *
 */
public class Student  implements Cloneable,Serializable{
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;
	private Integer age;
	private String name;
	private Prototype prototype;
	
	public Prototype getPrototype() {
		return prototype;
	}
	public void setPrototype(Prototype prototype) {
		this.prototype = prototype;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
	public Student(Integer age, String name, Prototype prototype) {
		this.age = age;
		this.name = name;
		this.prototype = prototype;
	}
	public Object deepClone() throws IOException, ClassNotFoundException{
		/**
		 *  写入当前对象的二进制流
		 */
		ByteArrayOutputStream bos =  new ByteArrayOutputStream();
		ObjectOutputStream oos =  new ObjectOutputStream(bos);
		oos.writeObject( this );
		
		/**
		 * 写出当前对象二进制流
		 */
		ByteArrayInputStream bis =  new ByteArrayInputStream(bos.toByteArray());
		ObjectInputStream ois;
		ois = new ObjectInputStream(bis);
		return ois.readObject();
	}
}

package com.dairuijie.prototype;

import java.io.IOException;

/**
 * 
 * @author DRJYY
 *
 */
public class ShallowTest {
	public static void main(String[] args) throws ClassNotFoundException, IOException {
		Prototype p = new Prototype(12, "dai");
		Student student = new Student(13, "dai", p);
		Student stu =	(Student) student.deepClone();
		stu.getPrototype().setAge(123);
		stu.setAge(11);
		System.out.println("原始的student的年龄----"+student.getAge());
		System.out.println("克隆对象----"+stu.getAge());
		System.out.println("克隆对象中的p 引用---"+stu.getPrototype().getAge());
		System.err.println("p的对象原始----"+p.getAge());
	}
}

package com.dairuijie.prototype;

public class DeepTest {
	public static void main(String[] args) throws CloneNotSupportedException {
		Prototype p = new Prototype(12, "dai");
		Student student = new Student(13, "dai", p);
		Student stu =	(Student) student.clone();
		stu.getPrototype().setAge(123);
		stu.setAge(11);
		System.out.println("原始的student的年龄----"+student.getAge());
		System.out.println("克隆对象----"+stu.getAge());
		System.out.println("克隆对象中的p 引用---"+stu.getPrototype().getAge());
		System.err.println("p的对象原始----"+p.getAge());
	}
}

图一  ：                                                                                  图二：

如图一就是浅复制结果 发现p 的对象年龄没有变化，图二深复制中p 的对象年龄却被身体stu.getPrototype().setAge(123) 改变了。说明深复制将引用对象都复制过来了。也就是对引用类型的成员变量也进行引用对象的复制。