工厂方法设计模式

Question

根据这本书:

工厂模式的本质是"定义用于创建对象的接口,但让子类决定实例化哪个类.Plant方法允许类将实例化延迟到子类.

说我有一个创作者类:

class Product; //this is what the Factory Method should return
class Creator {
    public:
        Creator()   //ctor
        { //... }

        virtual Product make(//args)
        { //... }
}

好吧,这是我的创作者课程,但我不明白

Factory方法允许类将实例化延迟到子类

它与子类有什么关系？我应该使用什么子类？

有谁可以给​​我一些例子？

Answer 1

你的Creator班级是工厂.我们称之为ProductFactory,以使示例更加明确.

(我假设您使用的是C++)

class Book : public Product
{
};

class Computer : public Product
{
};

class ProductFactory
{
public:
  virtual Product* Make(int type)
  {
    switch (type)
    {
      case 0:
        return new Book();
      case 1:
        return new Computer();
        [...]
    }
  }
}

像这样称呼它:

ProductFactory factory = ....;
Product* p1 = factory.Make(0); // p1 is a Book*
Product* p2 = factory.Make(1); // p2 is a Computer*
// remember to delete p1 and p2

那么,回答你的问题:

它与子类有什么关系？我应该使用什么子类？

工厂模式的定义是,工厂定义了一个用于创建特定类型实例的通用API(通常是接口或抽象类),但返回的实现的实际类型(因此是子类引用)是工厂.在该示例中,工厂返回Product实例,为其生成Book并且Computer是有效的子类.

工厂还有其他的习惯用法,例如为工厂提供API,工厂的具体实现在我的示例中不接受type,但它们与返回的实例类型相结合,如下所示:

class ProductFactory
{
public:
  virtual Product* Make() = 0;
}

class BookProductFactory : public ProductFactory
{
public:
    virtual Product* Make()
    {
      return new Book();
    }
}

在这个类中BookProductFactory总是返回Book实例.

ProductFactory* factory = new BookProductFactory();
Product* p1 = factory->Make(); // p1 is a Book
delete p1;
delete factory;

为了明确这一点,因为似乎有点混淆的Abstract Factory和Factory method设计模式,让我们来看看一个具体的例子:

使用抽象工厂

class ProductFactory {
protected:
  virtual Product* MakeBook() = 0;
  virtual Product* MakeComputer() = 0;
}

class Store {
public:
   Gift* MakeGift(ProductFactory* factory) {
     Product* p1 = factory->MakeBook();
     Product* p2 = factory->MakeComputer();
     return new Gift(p1, p2);
   }
}

class StoreProductFactory : public ProductFactory {
protected:
  virtual Product* MakeBook() { return new Book(); }
  virtual Product* MakeComputer() { return new Computer(); }
}

class FreeBooksStoreProductFactory : public StoreProductFactory {
protected:
  virtual Product* MakeBook() {
    Book* b = new FreeBook(); // a FreeBook is a Book with price 0
    return b;
  }
}

就像这样使用:

Store store;
ProductFactory* factory = new FreeBooksStoreProductFactory();
Gift* gift = factory->MakeGift(factory);
// gift has a FreeBook (Book with price 0) and a Computer
delete gift;
delete factory;

使用Factory方法

class Store {
public:
   Gift* MakeGift() {
     Product* p1 = MakeBook();
     Product* p2 = MakeComputer();
     return new Gift(p1, p2);
   }

 protected:
   virtual Product* MakeBook() {
     return new Book();
   }

   virtual Product* MakeComputer() {
     return new Computer();
   }
}

class FreeBooksStore : public Store {
protected:
  virtual Product* MakeBook() {
    Book* b = new FreeBook(); // a FreeBook is a Book with price 0
    return b;
  }
}

就像这样使用:

Store* store = new FreeBooksStore();
Gift* gift = store->MakeGift();
// gift has a FreeBook (Book with price 0) and a Computer
delete gift;
delete store;

当你type像我在原始例子中那样使用鉴别器时,我们正在使用parametized factory methods- 一种知道如何创建不同类型对象的方法.但这可以出现在一个Abstract Factory或一个Factory Method模式中.一个简单的技巧:如果您正在扩展工厂类,那么您正在使用Abstract Factory.如果使用创建方法扩展类,则使用工厂方法.