【HeadFirst 设计模式学习笔记】18 原型（Prototype）模式拾零

1.概述

这个模式在Head First这本书中也没有具体提到。其主要应用于如下场景：对于创建一个新的对象，若且你手中已经有了一个非常相像的对象实例，那么你可以利用这个现有对象进行新对象的创建。用现实中的例子来说，比如细胞分裂，一个细胞分裂为两个细胞（可能这个比喻在生物学上有些出入）。参与这个模式的两种实体为：

原型：一个提供克隆自己的接口的抽象。

具体原型：实现这个克隆自己的的接口的具体实现类。

2.实例

首先我们实现一个原型模式的原始例子，这里利用了Java中Object的clone()方法：

  1: public interface Prototype {
  2:     public abstract Object clone ( );
  3: }
  4: 
  5:  
  6: 
  7: public class ConcretePrototype implements Prototype {
  8:     public Object clone() {
  9:         return super.clone();
 10:     }
 11: }
 12: 
 13: public class Client {
 14: 
 15:     public static void main( String arg[] ) 
 16:     {
 17:         ConcretePrototype obj1= new ConcretePrototype ();
 18:         ConcretePrototype obj2 = ConcretePrototype)obj1.clone();
 19:     }
 20: 
 21: }
 22:  
 23: 

显然上边的这个例子并没有多少实用性，下边的例子中我们要创建一个具有克隆自己功能的表示相关产品的对象，实现上利用了简单工厂方法——这个经常和原型模式一起使用。

我们利用Java中的Cloneable接口定义原型，其中就提供了一个克隆自己的方法的接口定义。然后我们实现这个具体原型，当然相对于标准的原型模式，这里面有增加了一层产品的抽象，因为毕竟Java中的Cloneable是一个接口，需要有一层实现这个接口中clone方法的抽象作为抽象产品类。

  1: public abstract class Product implements Cloneable {
  2:     private String title;
  3:     private String price;
  4:     public String getTitle() {
  5:         return title;
  6:     }
  7:  
  8:     public void setTitle(String title) {
  9:         this.title = title;
 10:     }
 11:  
 12:     public String getPrice() {
 13:         return price;
 14:     }
 15:  
 16:     public void setPrice(String price) {
 17:         this.price = price;
 18:     }
 19:  
 20:     public Object clone() {
 21:         Object clone = null;
 22:         try {
 23:             clone = super.clone();
 24:         } catch (CloneNotSupportedException e) {
 25:             e.printStackTrace();
 26:         }
 27:         return clone;
 28:     }
 29: }

然后我们根据这个抽象类创建两个具体的原型类，如果用简单工厂方法的视角那就是一个具体产品类，不过这并不要紧：

  1: public class Book extends Product {
  2:     private String author;
  3:  
  4:     public String getAuthor() {
  5:         return author;
  6:     }
  7:     public void setAuthor(String author) {
  8:         this.author = author;
  9:     }
 10: } 

  1: public class Cloths extends Product {
  2:     private int size;
  3:  
  4:     public int getSize() {
  5:         return size;
  6:     }
  7:  
  8:     public void setSize(int size) {
  9:         this.size = size;
 10:     }
 11: }

现在我们创建一个工厂（为了演示多个具体产品类，这个工厂定义的比较特殊——生产书和衣服）来创建这些产品：

  1: public class ProductFactory {
  2:     private static Hashtable productMap = new Hashtable();
  3:  
  4:     public static Product getProduct(String productCode) {
  5:         Product cachedProduct = (Product) productMap.get(productCode);
  6:         return (Product) cachedProduct.clone();
  7:     }
  8:  
  9:     public static void loadCache() {
 10:         Book book = new Book();
 11:         book.setTitle("Java best practices");
 12:         book.setAuthor("Prashant");
 13:         book.setPrice("100");
 14:         productMap.put(book.getTitle(), book);
 15:         Cloths cloths = new Cloths();
 16:         cloths.setTitle("Jeans");
 17:         cloths.setSize(32);
 18:         cloths.setPrice("450");
 19:         productMap.put(cloths.getTitle(),cloths);
 20:     }
 21: }

这个工厂的特殊之处是需要复制的对象已经创立好了，在创建工厂实例的时候通过loadCache就可以完成。

下边我们使用这个工厂克隆生产一本书和一件衣服：

  1: public class ProductOutlet {
  2:     public static void main(String[] args) {
  3:         ProductFactory.loadCache();
  4:         Book clonedBook = (Book) ProductFactory.getProduct("Java best practices");
  5:         System.out.println("Product cloned as Book");
  6:         System.out.println("Title = " + clonedBook.getTitle());
  7:         System.out.println("Author = " + clonedBook.getAuthor());
  8:         System.out.println("Price = " + clonedBook.getPrice());
  9:         System.out.println("Product cloned as Cloths");
 10:         Cloths clonedCloths = (Cloths) ProductFactory.getProduct("Jeans");
 11:         System.out.println("Title = " + clonedCloths.getTitle());
 12:         System.out.println("Size = " + clonedCloths.getSize());
 13:         System.out.println("Price = " + clonedCloths.getPrice());
 14:     }
 15: }

这里没有画简单工厂模式的实体。

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

本文转自gnuhpc博客园博客，原文链接：http://www.cnblogs.com/gnuhpc/archive/2012/12/21/2827653.html，如需转载请自行联系原作者