设计模式 （五）原型模式(Prototype)

原型模式就是通过一个原型对象来表明要创建的对象类型，然后用复制这个原型对象的方法来创建更多同类型的对象。

自己对原型模式简单理解的原理图如下：

具体属性没有添加：

原型模式里面关键点就在一个Cloneable接口和clone方法的重写

下面就通过一个配钥匙的例子简单的写了一个程序，起初一个一个抽象类，这样可以重写clone方法，如果是接口的话就得到子类里面把重写的方法具体声明，这样的话对于程序的复用性不是很好，于是就写了一个抽象的类KeyPrototype然后，写了两个子类继承一个客户端，代码如下：

package com.designpattern.prototype;

public abstract class KeyPrototype implements Cloneable {
	private String color;
	private float length;
	private float thick;

	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}

	@Override
	public String toString() {
		return this.getClass() + " -> Color:" + this.getColor() + " Length:"
				+ this.getLength() + " Thick:" + this.getThick();
	}

	public String getColor() {
		return color;
	}

	public float getLength() {
		return length;
	}

	public float getThick() {
		return thick;
	}

	public void setColor(String color) {
		this.color = color;
	}

	public void setLength(float length) {
		this.length = length;
	}

	public void setThick(float thick) {
		this.thick = thick;
	}

}

package com.designpattern.prototype;

public class CopperKey extends KeyPrototype {
	
}

package com.designpattern.prototype;

public class AluminiumKey extends KeyPrototype {

}

package com.designpattern.prototype;

public class Client {
	public static void main(String[] args) {
		KeyPrototype copperkey = new CopperKey();
		copperkey.setColor("red");
		copperkey.setLength(12);
		copperkey.setThick(2);
		System.out.println(copperkey);

		try {
			KeyPrototype aluminaumkey = (KeyPrototype) copperkey.clone();
			aluminaumkey.setColor("yellow");
			aluminaumkey.setLength(10);
			aluminaumkey.setThick(5);
			System.out.println(aluminaumkey);
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
	}
}

class com.designpattern.prototype.CopperKey -> Color:red Length:12.0 Thick:2.0
class com.designpattern.prototype.CopperKey -> Color:yellow Length:10.0 Thick:5.0

这样就简单对前者进行的复制，很显然他们并不是一个对象，里面关于clone的东西做了一个简单的总结

同时来证明他们确实是两个对象，就是改动里面的属性不互相影响：

首先我创建了一个Dog类

package com.note.clone;

public class Dog/* implements Cloneable  */{
	private String color;
	private String name;
	public Dog(String name,String color){
		this.name = name;
		this.color = color;
	}

	public String getColor() {
		return color;
	}

	public void setColor(String color) {
		this.color = color;
	}

	public String getName() {
		return name;
	}

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

/*	@Override
	protected Object clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		return super.clone();
	}*/

	@Override
	public String toString() {
		return this.getClass()+" "+this.getName()+" "+this.getColor();
	}
	
	
}

然后写了一个Tom类，其中Tom类里面有私有属性Dog

package com.note.clone;

public class Tom implements Cloneable {
	private String color;
	private Dog dog = new Dog("mimi", "yellow");;
	private String name;

	@Override
	protected Object clone() throws CloneNotSupportedException {
		Tom o = null;
		o = (Tom)super.clone();
//		o.setDog((Dog)o.getDog().clone());
		return o;
	}

	public String getColor() {
		return color;
	}

	public Dog getDog() {
		return dog;
	}

	public String getName() {
		return name;
	}

	public void setColor(String color) {
		this.color = color;
	}

	public void setDog(Dog dog) {
		this.dog = dog;
	}

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

	@Override
	public String toString() {
		return this.getClass() + " " + this.getName() + " " + this.getColor()
				+ "\n" + "Dog:" + this.dog;
	}

}

然后写了一个People类简单的对上述的两个程序进行测试：

package com.note.clone;

public class People {

	public static void main(String[] args) {
		Tom tom = new Tom();
		tom.setName("Tom");
		tom.setColor("blue");
		System.out.println(tom);
		System.out.println();
		
		try {
			Tom tylo = (Tom) tom.clone();
			tylo.setName("tylo");
			tylo.setColor("red");
			tylo.getDog().setName("lucky");
			tylo.getDog().setColor("green");
			System.out.println(tylo);
			System.out.println();
			System.out.println(tom);
			System.out.println();

			Dog dog = tylo.getDog();
			dog.setName("hello");
			dog.setColor("white");
			System.out.println(tylo);
			System.out.println();
			System.out.println(tom);
			System.out.println();

		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}

	}
}

运行结果如下：

class com.note.clone.Tom Tom blue
Dog:class com.note.clone.Dog mimi yellow

class com.note.clone.Tom tylo red
Dog:class com.note.clone.Dog lucky green

class com.note.clone.Tom Tom blue
Dog:class com.note.clone.Dog lucky green

class com.note.clone.Tom tylo red
Dog:class com.note.clone.Dog hello white

class com.note.clone.Tom Tom blue
Dog:class com.note.clone.Dog hello white

这样很明确的表明了对于这两个对象的属性，自己的属性除了Dog以外都是自己的，没有对着对方的属性的改变而改变，但是Dog属性，两个对象的属性是一样的

那么这里就到了深度克隆

我们把Dog和Tom里注释掉的内容打开再运行People程序，运行结果如下：

class com.note.clone.Tom Tom blue
Dog:class com.note.clone.Dog mimi yellow

class com.note.clone.Tom tylo red
Dog:class com.note.clone.Dog lucky green

class com.note.clone.Tom Tom blue
Dog:class com.note.clone.Dog mimi yellow

class com.note.clone.Tom tylo red
Dog:class com.note.clone.Dog hello white

class com.note.clone.Tom Tom blue
Dog:class com.note.clone.Dog mimi yellow

很明显发现，两个对象的Dog属性也没有互相影响，说明了他们不是用的一个引用，这样也证明了上面的例子，他们分别是一个对象，达到了克隆复用的应用。

在原型模式中，可以动态的添加产品分类，而且对整体结构没有影响。

由于原型模式需要给每一个类都配备一个克隆方法，这就需要在这几类的时候通盘考虑，因为在已有类的基础上来添加clone操作时比较困难的，而且原型模式在实现深层的复制时，需要编写一定量的代码。