初学Java设计模式随记 -- 原型(Prototype)模式

原型(Prototype)模式也有叫原始模型模式。

 

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

 

2. 参与者：
•抽象原型（Prototype）： 声明一个克隆自身的接口。
•具体原型（Concrete Prototype）： 实现一个克隆自身的操作。
• 客户端（Client）：让一个原型克隆自身从而创建一个新的对象。

 

3.结构：

 

 

根据定义来看，原型模式就是用来复制对象的。

 

那么什么时候用原型模式呢？

 

还是用生产汽车的例子来理解。 

首先，根据定义可以知道，原型模式是需要克隆自身的，那么，这就是说，必须有一个产品原型。

也就是说原型模式中的原型还是需要使用通过工厂方法，或其他方法先创建出来。

 

这么看来，原型模式是在生产多个相同或相似的产品对象的时候使用的。

 

那么，使用原型模式有什么优势呢？

 

假设生产一辆奥迪A6，可以考虑使用工厂模式（甚至建造者模式）。

 

1.如果我有了一辆奥迪A6，用的很不错，我的朋友也想要一辆，可是我们不知道是由哪家工厂生产的，不知道去哪购买。如果我的奥迪A6可以自己复制一辆，我的朋友是不是会很方便，甚至不用花钱了。（这是在做美梦呀！！）

使用原型模式，只要克隆它就可以了。

这样就不需要知道这个产品是由哪个工厂生产的，只要复制它，就可以快速的有一个新的产品对象了。

这样一来使得系统更加独立于产品的创建、构成和表示。因为它是由自己实现产品自身的创建的。

 

2.如果是需要再生产其他型号的汽车，例如奥迪A8。

在工厂模式中，我们通常需要再建一个奥迪A8的工厂。

 

因为奥迪A8和奥迪A6是一个产品等级的，如果克隆一个奥迪A6的产品对象，并修改一些属性，就可以创建出来新的产品对象奥迪A8。这样，就不需要新的工厂了。（厂家也在做美梦呢！！）

也就是说，这样避免了创建一个与产品类层次平行的工厂类层次。

 

 

 由于使用原型模式，产品的创建过程更有独立性，不需要对应的工厂类，是产品内部的方法来创建的。所以，更容易动态地实现新产品类的增加和原有产品类的减少，不会对原有系统的结构造成影响。

 

 

怎么实现原型模式呢？

就是要实现原型的自我复制（克隆）。这就涉及到了浅克隆和深克隆的概念：（摘自阎宏的《Java与模式》）

1. 浅复制（浅克隆）
被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。

2. 深复制（深克隆）
被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。

 

3．利用串行化来做深复制
把对象写到流里的过程是串行化（Serilization）过程，但是在Java程序师圈子里又非常形象地称为“冷冻”或者“腌咸菜（picking）”过程；而把对象从流中读出来的并行化（Deserialization）过程则叫做“解冻”或者“回鲜(depicking)”过程。应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面，因此“腌成咸菜”的只是对象的一个拷贝，Java咸菜还可以回鲜。
在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里（腌成咸菜），再从流里读出来（把咸菜回鲜），便可以重建对象。

 

Java的clone（）方法：
clone方法将对象复制了一份并返回给调用者。一般而言，clone（）方法满足：
①对任何的对象x，都有x.clone() !=x//克隆对象与原对象不是同一个对象
②对任何的对象x，都有x.clone().getClass()= =x.getClass()//克隆对象与原对象的类型一样
③如果对象x的equals()方法定义恰当，那么x.clone().equals(x)应该成立。

Java中对象的克隆
①为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。
②在派生类中覆盖基类的clone()方法，并声明为public。
③在派生类的clone()方法中，调用super.clone()。
④在派生类中实现Cloneable接口。

 

Java中实现的代码：

浅复制（浅克隆）：

汽车类：

 

/*
 * 汽车类
 * 
 * 浅克隆（shadow clone）的实现
 */
public class Car implements Cloneable {
	
//	汽车款式
	public int type;

//	引用的其他对象,汽车发动机
	public Engine engine;

	public Object clone() {
		
		Object clone = null;
		try {

//			这里只是克隆的自己本身
			clone = super.clone();
			
//			为什么在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢？
//			因为，在运行时刻，Object中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，
//			将原始对象的内容一一复制到新对象的存储空间中。	
			
		} catch (CloneNotSupportedException e) {

		}
		return clone;
	}

}

 

发动机类：

/*
 * 汽车发动机类，汽车类中引用的对象的类
 */
public class Engine implements Cloneable {
	
//	汽车发动机型号
	public int model;

}

 

客户端调用：

/*
 * 浅克隆（shadow clone）的调用
 */
public class Client {
	   public static  void main(String argv[])
	   {
		 System.out.println("-----创建汽车1-----");
		 Car car1=new Car();
	     car1.engine=new Engine();
	     car1.type=1;
	     car1.engine.model=1;
	     System.out.println("汽车1款式："+car1.type+"\t汽车1的发动机型号："+car1.engine.model);
	     
	     System.out.println("----汽车1--克隆-->汽车2----");
	     Car car2=(Car)car1.clone();
	     car2.type=2;
	     car2.engine.model=2;
	     
	     System.out.println("汽车2款式："+car2.type+"\t汽车2的发动机型号："+car2.engine.model);
	     System.out.println("汽车1款式："+car1.type+"\t汽车1的发动机型号："+car1.engine.model);
	   }
	 }

 

运行结果：

-----创建汽车1-----
汽车1款式：1	汽车1的发动机型号：1
----汽车1--克隆-->汽车2----
汽车2款式：2	汽车2的发动机型号：2
汽车1款式：1	汽车1的发动机型号：2

 

根据运行结果可以发现，浅复制（浅克隆）仅仅复制所考虑的对象，而不复制它所引用的对象。
所以，当设定汽车2的发动机型号为2 时，也将汽车1的发动机型号有1变成了2。

因为汽车1和汽车2实际上使用的是同一个发动机

 

深复制（深克隆）：

怎么实现深复制（深克隆）呢？修改一下汽车类和汽车发动机类：

 

汽车类：

/*
 * 深克隆
 */
public class Car implements Cloneable {
	
	public int type;

//	引用的其他对象
	public Engine engine;

	public Object clone() {

		Car temp = null;
		try {

//			先把自己本身复制
			temp = (Car) super.clone();
			
//			为了实现深度克隆，需要将对其他对象（在这里是engine）的引用都复制过去。
			temp.engine = (Engine) engine.clone();
		} catch (CloneNotSupportedException e) {
			// should never happen
		}

		return temp;
	}
}

 

发动机类：

public class Engine implements Cloneable {
	public int model;

	/**
	 * 为了实现深度克隆，需要给在Lay1中被应用的对象lay2）也提供一个自己克隆自身的方法
	 */
	public Object clone() {
		Object clone = null;
		try {
			clone = super.clone();
		} catch (CloneNotSupportedException e) {

		}
		return clone;
	}

}

 

客户端调用不变。

 

运行结果：

-----创建汽车1-----
汽车1款式：1	汽车1的发动机型号：1
----汽车1--克隆-->汽车2----
汽车2款式：2	汽车2的发动机型号：2
汽车1款式：1	汽车1的发动机型号：1

 

根据运行结果可以发现，深复制（深克隆）把要复制的对象所引用的对象都复制了一遍。

所以，当设定汽车2的发动机型号为2 时，汽车1的发动机型号还是1，没有变化。

因为，汽车1和汽车2拥有了两个不同的发动机。

 

利用串行化来做深复制（深克隆）：

 

汽车类

实现了串行（序列）化接口，并使用了在流中读取和写入对象。

 

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

/*
 * 汽车类
 * 
 * 序列化的方式实现深克隆（deep clone）
 */
public class Car implements Serializable {

	/**
	 * serialVersionUID 
	 */
	private static final long serialVersionUID = 1859639569305572020L;

//	汽车款式
	public int type;

//  引用的其他对象,汽车发动机
	public Engine engine;

	public Object clone() {

		try {

//			将对象写到流里，把对象写到流里的过程是串行化（Serilization）过程

			ByteArrayOutputStream bo = new ByteArrayOutputStream();
			ObjectOutputStream oo;

			oo = new ObjectOutputStream(bo);

			oo.writeObject(this);

//			从流里读出来，把对象从流中读出来的并行化（Deserialization）过程
			ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
			ObjectInputStream oi = new ObjectInputStream(bi);
			return (oi.readObject());

		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			return null;
		} catch (IOException e) {
			// TODO Auto-generated catch block
			return null;
		}
	}
}

 

 

汽车发动机类：

 

import java.io.Serializable;

public class Engine implements Cloneable, Serializable {

	/**
	 * Car对象以及对象内部所有引用到的对象engine都是可串行化的
	 */
	private static final long serialVersionUID = -6228724315977120960L;

	public int model;

}

 

 

客户端调用不变。

 

运行结果：

-----创建汽车1-----
汽车1款式：1	汽车1的发动机型号：1
----汽车1--克隆-->汽车2----
汽车2款式：2	汽车2的发动机型号：2
汽车1款式：1	汽车1的发动机型号：1

 

根据运行结果可以发现，通过串行化的方式也实现了深复制（可克隆）。

所以，当设定汽车2的发动机型号为2 时，汽车1的发动机型号还是1，没有变化。

因为，汽车1和汽车2拥有了两个不同的发动机。