原型模式--自我复制（结合Java浅复制与深复制）

原型模式，字面上的理解，以原型为标杆的模式。

原型模式其实就是从一个对象再创建另外一个可定制对象，而且不需知道任何创建的细节。

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

Java里面一个比较典型的就是Cloneable接口，通过实现Cloneable接口，我们可以进行对象

的复制，这里当然就会讲到浅复制与深复制。

首先来看看原型模式的类图吧：

这里的Prototype是个基础的原型类，它实现了一个Cloneable的接口，也就是它能够把信息复制给另外一个类。

另外ConcretePrototype1和ConcretePrototype2继承自Prototype，因而也就有克隆功能，并且基于Prototype类

这个原型。

相关类图的代码就不贴了，这里主要给出Java中的深复制和浅复制的例子吧，便于理解。

PrototypeA类（用于浅复制）：

package com.blog.anla.Prototype;

/**
 * 原型类，声明一个克隆自身的接口 以浅复制为例
 * @author U-ANLA
 *
 */
public class PrototypeA implements Cloneable {

	private int num1 = 0;
	private int num2 = 0;

	private People people;
	
	public PrototypeA(){
		people = new People();
	}

	@Override
	protected Object clone() throws CloneNotSupportedException {
		//并没有对people这个引用对象进行特殊处理
		return (Object) super.clone();
	}

	public int getNum1() {
		return num1;
	}

	public void setNum1(int num1) {
		this.num1 = num1;
	}

	public int getNum2() {
		return num2;
	}

	public void setNum2(int num2) {
		this.num2 = num2;
	}

	public People getPeople() {
		return people;
	}

	public void setPeople(People people) {
		this.people = people;
	}

	@Override
	public String toString() {
		return "PrototypeA [num1=" + num1 + ", num2=" + num2 + ", people="
				+ people + "]";
	}
}

PrototypeB类（用于测试深复制）：

package com.blog.anla.Prototype;
/**
 * 原型模式，以深复制为例
 * @author U-ANLA
 *
 */
public class PrototypeB {
	private int num1 = 0;
	private int num2 = 0;

	private People people;
	
	public PrototypeB(){
		people = new People();
	}

	@Override
	protected PrototypeB clone() throws CloneNotSupportedException {
		//新创建了一个对象并返回
		PrototypeB pb = new PrototypeB();
		pb.num1 = this.num1;
		pb.num2 = this.num2;
		pb.people = pb.people;
		return (PrototypeB)pb;
	}

	public int getNum1() {
		return num1;
	}

	public void setNum1(int num1) {
		this.num1 = num1;
	}

	public int getNum2() {
		return num2;
	}

	public void setNum2(int num2) {
		this.num2 = num2;
	}

	public People getPeople() {
		return people;
	}

	public void setPeople(People people) {
		this.people = people;
	}

	@Override
	public String toString() {
		return "PrototypeB [num1=" + num1 + ", num2=" + num2 + ", people="
				+ people + "]";
	}

}

辅助类People:

package com.blog.anla.Prototype;
/**
 * 模板类，用来测试并区分浅复制和深复制。
 * @author U-ANLA
 *
 */
public class People {
	private String name;
	private int age;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "People [name=" + name + ", age=" + age + "]";
	}
	public People(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public People() {

	}
	
	
}

测试类Main：

package com.blog.anla.Prototype;
/**
 * 测试的深复制浅复制类，很明显，两个输出不同
 * 浅复制只会复制基本类型，而对于引用类型，则是直接给指向的应用
 * 而深复制除了可以复制基本类型外，还能够复制一套引用类型变量。
 * @author U-ANLA
 *
 */
public class Main {
	public static void main(String[] args) throws CloneNotSupportedException {
		//浅复制
		PrototypeA pa = new PrototypeA();
		pa.setNum1(5);
		pa.setNum2(6);
		pa.getPeople().setAge(25);
		pa.getPeople().setName("Jack");
		PrototypeA pa1 = (PrototypeA)pa.clone();
		//修改pa1的值而不修改pa2的相关值。
		pa1.getPeople().setAge(23);
		pa1.setNum1(4);
		//对比结果
		System.out.println(pa);
		System.out.println(pa1);
		/**
		 * 输出结果：
		 * PrototypeA [num1=5, num2=6, people=People [name=Jack, age=23]]
		 * PrototypeA [num1=4, num2=6, people=People [name=Jack, age=23]]
		 */
		System.out.println();
		System.out.println();
		
		
		
		//深复制
		PrototypeB pb = new PrototypeB();
		pb.setNum1(5);
		pb.setNum2(6);
		pb.getPeople().setAge(25);
		pb.getPeople().setName("Jack");
		PrototypeB pa2 = (PrototypeB)pb.clone();
		//修改pa1的值而不修改pa2的相关值。
		pa2.getPeople().setAge(23);
		pa2.getPeople().setName("Tom");
		pa2.setNum1(4);
		//对比结果
		System.out.println(pb);
		System.out.println(pa2);
		/**
		 * 输出结果：
		 * PrototypeB [num1=5, num2=6, people=People [name=Jack, age=25]]
		 * PrototypeB [num1=4, num2=6, people=People [name=Tom, age=23]]
		 */
		
	}
}

赠人玫瑰手留余香，希望有助于理解原型模式以及浅复制和深复制（oo）