原型模式(Prototype)

一、介绍

原型模式是在已指定对象的基础上，然后通过拷贝这些原型对象创建新的对象。

 

 

二、实例

实例的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操作。当内部包括一些不支持拷贝或由循环引用的对象时，实现克隆可能也会很困难的。