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

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

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

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)