23种设计模式学习之：原型模式

原型模式：

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

java例子：

//car

public class Car implements Serializable{
	private static final long serialVersionUID = 1L;
	public String type;
}

//浅复制

public class CarProduct implements Cloneable{
	public int id;
	public String name;
	public Car car;
	public Object clone() throws CloneNotSupportedException{
		CarProduct cp = (CarProduct)super.clone();
		return cp;
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Car getCar() {
		return car;
	}
	public void setCar(Car car) {
		this.car = car;
	}
}

//深复制

public class CarProduct2 implements Cloneable,Serializable{
	private static final long serialVersionUID = 1L;
	private int id;
	private String name;
	private Car car;//也需要实现Serializable接口
	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 = new ObjectInputStream(bis);
		return ois.readObject();
	}
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Car getCar() {
		return car;
	}
	public void setCar(Car car) {
		this.car = car;
	}
}

//测试

public class CloneTest {
	public static void main(String[] args) throws 
	CloneNotSupportedException, ClassNotFoundException, IOException{
		//浅复制
		CarProduct cp = new CarProduct();
		cp.setId(21);
		cp.setName("Maserati");
		cp.setCar(new Car());
		CarProduct cp1 = (CarProduct)cp.clone();
		System.out.println("浅复制："+(cp.getId()==cp1.getId()));
		System.out.println("浅复制："+(cp.getName()==cp1.getName()));
		System.out.println("浅复制："+(cp.getCar()==cp1.getCar()));
		System.out.println("----------");
		//深复制
		CarProduct2 cp2 = new CarProduct2();
		cp2.setId(21);
		cp2.setName("Maserati");;
		cp2.setCar(new Car());;
		CarProduct2 cp3 = (CarProduct2)cp2.deepClone();
		System.out.println("深复制："+(cp2.getId()==cp3.getId()));
		System.out.println("深复制："+(cp2.getName()==cp3.getName()));
		System.out.println("深复制："+(cp2.getCar()==cp3.getCar()));
	}
}

//测试结果

浅复制：true
浅复制：true
浅复制：true
----------
深复制：true
深复制：false
深复制：false

总结：

1. 浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原来的所指的对象。
2. 深复制：将一个对象复制后，不论是基本数据类型的变量还是引用类型，都是重新创建。简单的说，就是深复制进行了完全彻底的复制，而浅复制不彻底。