设计模式之(二)原型模式Prototype

最新推荐文章于 2025-06-26 18:02:38 发布

转载最新推荐文章于 2025-06-26 18:02:38 发布 · 580 阅读

文章标签：

#设计模式 #prototype #产品 #object #class #java

设计模式专栏收录该内容

23 篇文章

订阅专栏

本文详细介绍了原型模式的概念、应用场景以及其实现方式。通过具体实例展示了如何使用原型模式来提高程序效率，尤其是在创建复杂或耗时的对象时。同时，还讨论了原型模式的优缺点及其在动态环境下的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、介绍

原型模式是创建型模式的一种,其特点在于通过“复制”一个已经存在的实例来返回新的实例,而不是新建实例。被复制的实例就是我们所称的“原型”，这个原型是可定制的。

原型模式多用于创建复杂的或者耗时的实例，因为这种情况下，复制一个已经存在的实例使程序运行更高效；或者创建值相等，只是命名不一样的同类数据。

二、实例

实例的UML图如下：

提供一个基本的原型工厂类，定义make方法和传入参数定义：

      Java代码  
     
    
 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()方法：

       Java代码  
      
     
 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方面的原型接口及实际类：

        Java代码  
       
      
 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");      
    }      
 }  

看看，在实际工作中，我们如何运用原型模式吧！

       Java代码  
      
     
 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 
    } 
}

四、原型管理器

　　原型对象在原型模式中居于核心的地位。一个系统能产生的对象的种类多少，取决于系统中存在多少原型。当一个系统中原型对象较多或数量不固定，需要能动态的增加或删除的时候，我们就需要提供一个注册表机制，让客户能存储、检索和管理可用原型池——这个注册表称为原型管理器。

原型管理器一般是一个关联型存储器，比如哈希表，它包含一些基本操作可以通过关键字来注册、检索、删除原型。

总结

原型模式应用于希望系统独立于产品的创建、表示和构成时，这和工厂模式很类似。事实上，和工厂模式相同的是，原型模式同样对客户隐藏了对象的创建工作，但是，与工厂模式通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。工厂模式适用于产品种类有限的情况下，当产品数量巨大或需要提供动态产品增删等性能时，使用原型模式具有更强的适应性。

　　原型模式适用于以下情况（GoF）：