5

原型模式的目标是通过降低创建成本来克隆对象。这是一个例子：

class Complex {
    int[] nums = {1,2,3,4,5};
    public Complex clone() {
        return new Complex();//this line create a new object, so is it violate the objective             of prototype ?//
    }
}

class Test2 {
   Complex c1 = new Complex();
   Complex makeCopy() {
      return (Complex)c1.clone();// Is it actually create a new object ? based on the clone method in Complex class? //
   }
   public static void main(String[] args) {
       Test2 tp = new Test2();
       Complex c2 = tp.makeCopy();
   }
}

我认为这是用于深拷贝。那么，有人可以帮我解决这个问题吗？？？

4

4 回答 4

1

首先，要使这个工作正常，您的 Complex 类需要实现Cloneable标记接口，以向 Object.clone() 方法指示该方法制作该类实例的逐个字段副本是合法的。然后你需要重写 Object.clone() 方法来指定复制行为：

public Complex clone(){
    Complex clone = (Complex)super.clone();
    clone.nums = this.nums;
    return clone;
}
于 2010-08-20T17:00:20.977 回答
0

我不认为给出的示例是按照原型模式实现的。

我看到的错误是：

  1. 未实现可克隆标记接口。
  2. 在覆盖的克隆方法中使用“new Complex()”构造函数创建新实例。这不应该是这样。我的意思是在原型模式中，我们应该复制源代码，进行一些更改并根据要求使用克隆。但不创建新实例。通过克隆可以避免创建实例的成本，但是如果我们覆盖克隆方法并自己创建它的实例，您实际上会增加它的成本。

了解原型模式的一些链接：

http://www.javabeat.net/tips/34-using-the-prototype-pattern-to-clone-objects.html

http://www.allapplabs.com/java_design_patterns/prototype_pattern.htm

于 2010-08-20T17:31:47.480 回答
0

克隆方法的 java 实现不会调用类构造函数。它会将当前实例占用的内存复制到内存中的另一个位置。

这就是它真正降低新对象创建成本的方式。

于 2010-08-20T17:32:35.263 回答
0

您所说的部分正确，因为原型模式的目标是通过克隆和避免“新”来降低创建对象的成本。

但这并不意味着您可以使用该模式来克隆对象。还有其他重要的考虑

  • 使用原型对象作为所有其他实例的“制造者”。
  • 从给定的实例中创建“几乎”相似的实例，原型

总而言之，原型的目标是：

  • 通过克隆“原型对象”来降低创建对象的成本
  • 当通过原型创建的对象将与原型对象略有不同。

下面是一个使用原型 PageBanner 实例创建不同类型的页面横幅的示例，这些横幅略有不同

 import java.awt.Dimension;
 import java.io.Serializable;

/**
 * This class also acts as a factory for creating prototypical objects.
 */
public class PageBanner implements Serializable, Cloneable  {
   private String slogan;
   private String image;
   private String font;
   private Dimension dimension;

   // have prototype banner from which to derive all other banners
   private static final PageBanner PROTOTYPE = new PageBanner("", 
       "blank.png", "Verdana", new Dimension(600, 45));

   PageBanner(String slogan, String image, String font, 
         Dimension dim)   {
      this.slogan = slogan;
      this.image = image;
      //... other assignments
   }

   // getters and setters..

   public String toString()   {
      return new StringBuilder("PageBanner[")
            .append("Slogan=").append(slogan)
            .append("Image=").append(image)
            .append("Font=").append(font)
            .append("Dimensions=").append(dimension)
            .toString();

   }

   protected Object clone()  {
      Object cln = null;
      try   {
         cln = super.clone();
      }catch(CloneNotSupportedException e)   {
         // ignore, will never happen
      }
      return cln;
   }

   /**
    * This is the creational method that uses the prototype banner 
    * to create banners and changes it slightly (setting slogan and image)
    */
   public static PageBanner createSloganBanner(String slogan, String image)   {
      PageBanner banner = (PageBanner) PROTOTYPE.clone();
      banner.slogan = slogan;
      banner.image = image;
      return banner;
   }

   /**
    * Another creational method that uses the prototype banner 
    * to create banners and changes it slightly (setting image)
    */
   public static PageBanner createImageBanner(String image)   {
      PageBanner banner = (PageBanner) PROTOTYPE.clone();
      banner.image = image;
      return banner;
   }

   // similarly you can have a number of creational methods with 
   // different parameters for different types of banners that 
   // vary slightly in their properties.

   // main... (for illustration)
   public static void main(String[] args) {
      // both these banners are created from same prototypical instance
      PageBanner slogan = PageBanner.createSloganBanner(
            "Stackoverflow Rocks", "stack.png");
      PageBanner img = PageBanner.createImageBanner("stackBanner.png");
   }
}

哦，在你的情况下，让你的原型对象的类实现Cloneable标记接口

于 2010-08-21T05:09:08.520 回答