Java 设计模式之原型模式

原型模式是一种创建型设计模式，通过给出一个原型对象来指明所有创建的对象的类型，然后用复制这个原型对象的办法创建出更多同类型的对象。

原型模式有两种表现形式：

1）简单形式；

2）登记形式，这两种表现形式仅仅是原型模式的不同实现。

简单形式的原型模式，涉及到三种角色分别如下：

1）客户(Client)角色：客户类提出创建对象的请求。

2）抽象原型(Prototype)角色：这是一个抽象角色，通常由一个Java接口或Java抽象类实现。此角色给出所有的具体原型类所需的接口。

3）具体原型（Concrete Prototype）角色：被复制的对象。此角色需要实现抽象的原型角色所要求的接口。

原型模式中的拷贝分为"浅拷贝"和"深拷贝"：

浅拷贝: 对值类型的成员变量进行值的复制,对引用类型的成员变量只复制引用,不复制引用的对象。

深拷贝: 对值类型的成员变量进行值的复制,对引用类型的成员变量也进行引用对象的复制。

一、浅拷贝

只负责克隆按值传递的数据（比如基本数据类型、String类型），而不复制它所引用的对象，换言之，所有的对其他对象的引用都仍然指向原来的对象。

实体类，具体代码如下：

package com.yoodb;

public class Prototype implements Cloneable{
	private String name;

	public String getName() {
		return name;
	}

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

	@Override
	protected Object clone() {
		// TODO Auto-generated method stub
		try {
			return super.clone();
		} catch (CloneNotSupportedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}
	
	
}

测试函数，具体代码如下：

package com.yoodb;

public class TestMain {
	public static void main(String[] args) {
		Prototype pro = new Prototype();
		pro.setName("欢迎收藏www.yoodb.com");
		Prototype prot = (Prototype) pro.clone();
		prot.setName("欢迎收藏www.yoodb.com");
		System.out.println("original object：" + pro.getName());
		System.out.println("cloned object：" + prot.getName());
	}
	
}

运行结果如下：

original object：欢迎收藏www.yoodb.com
cloned object：欢迎收藏www.yoodb.com

二、深拷贝

除了浅度克隆要克隆的值外，还负责克隆引用类型的数据。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深度克隆把要复制的对象所引用的对象都复制了一遍，而这种对被引用到的对象的复制叫做间接复制。

实例一

实体类，具体代码如下：

package com.yoodb;

public class Prototype implements Cloneable{
	private String name;

	public String getName() {
		return name;
	}

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

	@Override
	protected Object clone() {
		// TODO Auto-generated method stub
		try {
			return super.clone();
		} catch (CloneNotSupportedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}
	
	
}

//实体二
package com.yoodb;

public class NewPrototype implements Cloneable{
	private String id;
	
	private Prototype prototype;

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public Prototype getPrototype() {
		return prototype;
	}

	public void setPrototype(Prototype prototype) {
		this.prototype = prototype;
	}

	@Override
	protected Object clone() {
		NewPrototype prot = null;
		try {
			prot = (NewPrototype) super.clone();
			prot.prototype = (Prototype) this.getPrototype().clone();
			return prot;
		} catch (Exception e) {
			// TODO: handle exception
		}
		return null;
	}
	
	
}

测试函数，具体代码如下：

package com.yoodb;

public class TestMain {
	public static void main(String[] args) {
		//普通赋值
		Prototype pro = new Prototype();
		pro.setName("欢迎收藏blog.yoodb.com");
		NewPrototype newPro = new NewPrototype();
		newPro.setId("yoodb");
		newPro.setPrototype(pro);
		//克隆赋值
		NewPrototype proc = (NewPrototype) newPro.clone();
		proc.setId("yoodb");
		proc.getPrototype().setName("欢迎收藏blog.yoodb.com");
		
		System.out.println("original object id：" + newPro.getId());
		System.out.println("original object name：" + newPro.getPrototype().getName());
		 
		System.out.println("cloned object id：" + proc.getId());
		System.out.println("cloned object name：" + proc.getPrototype().getName());
	}
	
}

运行结果如下：

original object id：yoodb
original object name：欢迎收藏blog.yoodb.com
cloned object id：yoodb
cloned object name：欢迎收藏blog.yoodb.com

实例二

利用串行化来实现深克隆，把对象写道流里的过程是串行化(Serilization)过程；把对象从流中读出来是并行化(Deserialization)过程。

实体类，具体代码如下：

package com.yoodb;

import java.io.Serializable;

public class Prototype implements Serializable{
	
	private static final long serialVersionUID = 1L;
	
	private String name;

	public String getName() {
		return name;
	}

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

//实体二
package com.yoodb;

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

public class NewPrototype implements Serializable{
	
	private static final long serialVersionUID = 1L;

	private String id;
	
	private Prototype prototype;

	public String getId() {
		return id;
	}

	public void setId(String id) {
		this.id = id;
	}

	public Prototype getPrototype() {
		return prototype;
	}

	public void setPrototype(Prototype prototype) {
		this.prototype = prototype;
	}

	protected Object deepClone(){
		try {
			ByteArrayOutputStream bo = new ByteArrayOutputStream();
			ObjectOutputStream oo = new ObjectOutputStream(bo);
			oo.writeObject(this);
			
			ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
			ObjectInputStream oi = new ObjectInputStream(bi);
			return oi.readObject();
		} catch (Exception e) {
			// TODO: handle exception
		}
		return null;
	}
	
}

测试函数，具体代码如下：

package com.yoodb;

public class TestMain {
	public static void main(String[] args) {
		//普通赋值
		Prototype pro = new Prototype();
		pro.setName("欢迎收藏www.yoodb.com");
		NewPrototype newPro = new NewPrototype();
		newPro.setId("yoodb");
		newPro.setPrototype(pro);
		//克隆赋值
		NewPrototype proc = (NewPrototype) newPro.deepClone();
		proc.setId("yoodb");
		proc.getPrototype().setName("欢迎收藏www.yoodb.com");
		
		System.out.println("original object id：" + newPro.getId());
		System.out.println("original object name：" + newPro.getPrototype().getName());
		 
		System.out.println("cloned object id：" + proc.getId());
		System.out.println("cloned object name：" + proc.getPrototype().getName());
	}
	
}

运行结果如下：

original object id：yoodb
original object name：欢迎收藏www.yoodb.com
cloned object id：yoodb
cloned object name：欢迎收藏www.yoodb.com

克隆满足的条件：

clone()方法将对象复制了一份并返还给调用者。所谓“复制”的含义与clone()方法是怎么实现的。一般而言，clone()方法满足以下的描述：

1)对任何的对象x，都有：x.clone()!=x。换言之，克隆对象与原对象不是同一个对象。

2)对任何的对象x，都有：x.clone().getClass() == x.getClass()，换言之，克隆对象与原对象的类型一样。

3)如果对象x的equals()方法定义其恰当的话，那么x.clone().equals(x)应当成立的。