一、介绍
原型模式是创建型模式的一种,其特点在于通过“复制”一个已经存在的实例来返回新的实例,而不是新建实例。被复制的实例就是我们所称的“原型”,这个原型是可定制的。
原型模式多用于创建复杂的或者耗时的实例,因为这种情况下,复制一个已经存在的实例使程序运行更高效;或者创建值相等,只是命名不一样的同类数据。
二、实例
实例的UML图如下:
提供一个基本的原型工厂类,定义make方法和传入参数定义:
- public class PrototypeFactory {
- AbstractSpoon prototypeSpoon;
- AbstractFork prototypeFork;
- public PrototypeFactory(AbstractSpoon spoon, AbstractFork fork) {
- prototypeSpoon = spoon;
- prototypeFork = fork;
- }
- public AbstractSpoon makeSpoon() {
- return (AbstractSpoon)prototypeSpoon.clone();
- }
- public AbstractFork makeFork() {
- return (AbstractFork)prototypeFork.clone();
- }
- }
定义原型抽象接口AbstractSpoon和原型实际类SoupSpoon,AbstractSpoon类实现了Colneable接口,并重载了clone()方法:
- public abstract class AbstractSpoon implements Cloneable {
- String spoonName;
- public void setSpoonName(String spoonName) {
- this.spoonName = spoonName;
- }
- public String getSpoonName() {
- return this.spoonName;
- }
- public Object clone() {
- Object object = null;
- try {
- object = super.clone();
- } catch (CloneNotSupportedException exception) {
- System.err.println("AbstractSpoon is not Cloneable");
- }
- return object;
- }
- }
- public class SoupSpoon extends AbstractSpoon {
- public SoupSpoon() {
- setSpoonName("Soup Spoon");
- }
- }
同样,我们也定义了另外一个Fork方面的原型接口及实际类:
- public abstract class AbstractFork implements Cloneable
- {
- String forkName;
- public void setForkName(String forkName) {
- this.forkName = forkName;
- }
- public String getForkName() {
- return this.forkName;
- }
- public Object clone()
- {
- Object object = null;
- try {
- object = super.clone();
- } catch (CloneNotSupportedException exception) {
- System.err.println("AbstractFork is not Cloneable");
- }
- return object;
- }
- }
- public class SaladFork extends AbstractFork {
- public SaladFork() {
- setForkName("Salad Fork");
- }
- }
看看,在实际工作中,我们如何运用原型模式吧!
- class TestPrototype {
- public static void main(String[] args) {
- System.out.println(
- "Creating a Prototype Factory with " +
- " a SoupSpoon and a SaladFork");
- PrototypeFactory prototypeFactory =
- new PrototypeFactory(new SoupSpoon(), new SaladFork());
- AbstractSpoon spoon =
- prototypeFactory.makeSpoon();
- AbstractFork fork =
- prototypeFactory.makeFork();
- System.out.println("Getting the Spoon and Fork name:");
- System.out.println("Spoon: " + spoon.getSpoonName() +
- ", Fork: " + fork.getForkName());
- System.out.println(" ");
- System.out.println("Creating a Prototype Factory " +
- "with a SaladSpoon and a SaladFork");
- prototypeFactory =
- new PrototypeFactory(new SaladSpoon(), new SaladFork());
- spoon = prototypeFactory.makeSpoon();
- fork = prototypeFactory.makeFork();
- System.out.println("Getting the Spoon and Fork name:");
- System.out.println("Spoon: " + spoon.getSpoonName() +
- ", Fork: " + fork.getForkName());
- }
- }
三、分析
从例子中,我们可以针对原型模式,统计出的以下这些角色:
- AbstractPrototype 原型接口或抽象类,实现了Cloneable接口,为工厂提供通用的原型接口声明。在该接口类中,重载实现了Cloneable接口的clone()方法。
- ConcretePrototype 原型实体对象定义类,可以由一个或多个,它也是加工工厂的实际原材料。
- PrototypeFactory 原型的加工工厂,用来定义原型对象的指定,以及拷贝复制的过程。
实现一个原型模式,需要以下几个关键步骤:
1、定义最基本的原型接口或抽象类AbstractPrototype,这里可以定义一种或多种不同的原型。
2、实现或继承已有的原型接口,定义实体原型对象类AbstractPrototype.
3、创建一个Client性质的类,如通用的PrototypeFactory ,通过原型模式来加工生产实际产品对象。
一句话总结原型模式的特点,即:请求一个原型来克隆对象自身。
通过给出一个原型对象来指明所要创建的对象的类型,然后用复制这个原型对象的方法创建出更多同类型的对象。原始模型模式允许动态的增加或减少产品类,产品类不需要非得有任何事先确定的等级结构,原始模型模式适用于任何的等级结构。
当然,原型模式也有它的缺点。每一个原型的子类都必须实现Clone操作,这可能会很困难。例如,当所考虑的类已经存在时就难以新增Clone操作。当内部包括一些不支持拷贝或由循环引用的对象时,实现克隆可能也会很困难的。
转自http://tailsherry.iteye.com/blog/121580还有一个比较简单的例子:
/** Prototype Class **/
public class Cookie implements Cloneable {
public Object clone()
{
try{
//In an actual implementation of this pattern you would now attach references to
//the expensive to produce parts from the copies that are held inside the prototype.
return this.getClass().newInstance();
}
catch(InstantiationException e)
{
e.printStackTrace();
return null;
}
}
}
/** Concrete Prototypes to clone **/
public class CoconutCookie extends Cookie { }
/** Client Class**/
public class CookieMachine
{
private Cookie cookie;//cookie必须是可复制的
public CookieMachine(Cookie cookie) {
this.cookie = cookie;
}
public Cookie makeCookie() {
return (Cookie)cookie.clone();
}
public Object clone() { }
public static void main(String args[]){
Cookie tempCookie = null;
Cookie prot = new CoconutCookie();
CookieMachine cm = new CookieMachine(prot); //设置原型
for(int i=0; i<100; i++)
tempCookie = cm.makeCookie();//通过复制原型返回多个cookie
}
}
四、原型管理器
总结
-
当要实例化的类是在运行时刻指定时,例如,通过动态装载;
-
为了避免创建一个与产品类层次平行的工厂类层次时;
-
当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。