Mẫu thiết kế: Tóm tắt Nhà máy vs Phương pháp Nhà máy

Lưu ý: Câu hỏi ở cuối bài.

Tôi đã đọc các luồng stackoverflow khác liên quan đến Tóm tắt Factory vs Factory Phương thức . Tôi hiểu ý định của từng mẫu. Tuy nhiên, tôi không rõ ràng về định nghĩa.

Factory Method định nghĩa một giao diện để tạo một đối tượng, nhưng cho phép các lớp con quyết định lớp nào sẽ khởi tạo. Một phương thức nhà máy cho phép các lớp trì hoãn việc khởi tạo các lớp con.

Ngược lại, một Nhà máy Trừu tượng cung cấp một giao diện để tạo các họ của các đối tượng liên quan hoặc phụ thuộc mà không chỉ định các lớp cụ thể của chúng.

- John Nữ

Các Abstract Factory trông rất giống với các phương pháp Factory . Tôi đã rút ra một vài lớp UML để minh họa quan điểm của mình.

Ghi chú:

• Sơ đồ là từ www.yuml.com vì vậy chúng không được định hướng hoàn hảo. Nhưng nó là một dịch vụ miễn phí :).
• Các sơ đồ có thể không hoàn hảo. Tôi vẫn đang học các mẫu thiết kế GoF .

Phương pháp nhà máy:

Nhà máy trừu tượng (chỉ có 1 thành viên):

Nhà máy trừu tượng (nhiều thành viên):

Câu hỏi:

1. Nếu Nhà máy Trừu tượng chỉ có một người tạo và một sản phẩm, thì đó có còn là mô hình Nhà máy Trừu tượng không? (một giao diện để tạo gia đình)
2. Có thể Factory Method tạo bê tông được tạo ra từ một giao diện hay nó phải là từ một lớp học? (các lớp trì hoãn tức thời đến các lớp con)
3. Nếu Nhà máy trừu tượng chỉ có thể có một người tạo và một sản phẩm, thì sự khác biệt duy nhất giữa Nhà máy trừu tượng và Phương thức nhà máy mà người tạo cho cái trước là Giao diện và người tạo cho cái sau là Class?

Hi vọng điêu nay co ich. Nó mô tả các loại nhà máy. Tôi đã sử dụng Head First Design Forms làm tài liệu tham khảo của mình. Tôi đã sử dụng yuml.me để sơ đồ.

Nhà máy tĩnh

Là một lớp có Phương thức tĩnh để tạo ra nhiều loại sản phẩm phụ khác nhau.

Nhà máy đơn giản

Là một lớp có thể sản xuất các loại sản phẩm phụ khác nhau. (Nó tốt hơn so với Nhà máy tĩnh. Khi các loại mới được thêm vào, lớp Sản phẩm cơ sở không cần phải thay đổi chỉ với Lớp nhà máy đơn giản)

Phương pháp nhà máy

Chứa một phương pháp để sản xuất một loại sản phẩm liên quan đến loại của nó. (Nó tốt hơn một Nhà máy đơn giản vì loại được hoãn lại cho một lớp con.)

Nhà máy trừu tượng

Tạo ra một họ các loại có liên quan. Nó khác biệt đáng kể so với Phương thức xuất xưởng vì nó có nhiều hơn một phương thức loại mà nó tạo ra. (Đây là phức tạp tham khảo sơ đồ tiếp theo cho ví dụ thực tế tốt hơn).

Ví dụ từ .NET Framework

DbFactoriesProvider là một Nhà máy đơn giản vì nó không có loại phụ. DbFactoryProvider là một nhà máy trừu tượng vì nó có thể tạo ra các đối tượng cơ sở dữ liệu liên quan khác nhau như các đối tượng kết nối và lệnh.

Hay nói, là một tài tài của, qua, qua, qua một tài khác, qua giữ, qua một tài khác

Hai mẫu chắc chắn có liên quan!

Sự khác biệt giữa các mẫu nói chung là trong ý định.

Các ý định của Nhà máy Phương pháp là "Xác định một giao diện để tạo một đối tượng, nhưng chúng ta hãy lớp con quyết định lớp để thuyết minh. Nhà máy Phương pháp cho phép một instantiation lớp hoãn đến lớp con."

Các ý định của Abstract Factory là "Cung cấp một giao diện để tạo các gia đình của các đối tượng có liên quan hoặc người phụ thuộc mà không quy định cụ thể các lớp bê tông của họ."

Dựa hoàn toàn vào các tuyên bố về ý định này (được trích dẫn từ GoF), tôi sẽ nói rằng thực sự Phương thức Nhà máy theo nghĩa nào đó là một Nhà máy Trừu tượng "thoái hóa" với một gia đình.

Họ thường có xu hướng khác nhau trong việc thực hiện, như Phương thức của Nhà máy đơn giản hơn nhiều so với Tóm tắt của Nhà máy .

Họ cũng có liên quan trong việc thực hiện. Như đã lưu ý trong cuốn sách của GoF,

AbstractFactory chỉ khai báo một giao diện để tạo sản phẩm. Tùy thuộc vào các lớp con Concrete sản phẩm để thực sự tạo ra chúng. Cách phổ biến nhất để làm điều này là xác định phương thức xuất xưởng cho từng sản phẩm.

Wiki c2 này cũng có một số thảo luận thú vị về chủ đề này.

Dường như danh sách các câu hỏi (xuất sắc) của OP đã bị bỏ qua. Các câu trả lời hiện tại chỉ đơn thuần cung cấp các định nghĩa được thử lại. Vì vậy, tôi sẽ cố gắng giải quyết các câu hỏi ban đầu một cách chính xác.

1. Nếu Nhà máy Trừu tượng chỉ có một người tạo và một sản phẩm, thì đó có còn là mô hình Nhà máy Trừu tượng không? (một giao diện để tạo gia đình)

Không . Một Nhà máy Trừu tượng phải tạo ra nhiều hơn một sản phẩm để tạo thành một "họ các sản phẩm liên quan". Ví dụ GoF chính tắc tạo ScrollBar()và Window(). Ưu điểm (và mục đích) là Nhà máy Trừu tượng có thể thực thi một chủ đề chung trên nhiều sản phẩm của mình.

2. Có thể Factory Method tạo bê tông được tạo ra từ một giao diện hay nó phải là từ một lớp học? (các lớp trì hoãn tức thời đến các lớp con)

Đầu tiên, chúng ta phải lưu ý rằng cả Java và C # đều không tồn tại khi GoF viết cuốn sách của họ. Việc sử dụng GoF của giao diện hạn không liên quan đến các loại giao diện được giới thiệu bởi các ngôn ngữ cụ thể. Do đó, trình tạo cụ thể có thể được tạo từ bất kỳ API nào. Điểm quan trọng trong mẫu là API sử dụng Phương thức xuất xưởng của chính nó, do đó, một giao diện chỉ có một phương thức không thể là Phương thức xuất xưởng nhiều hơn có thể là một Nhà máy trừu tượng.

3. Nếu Nhà máy trừu tượng chỉ có thể có một người tạo và một sản phẩm, thì sự khác biệt duy nhất giữa Nhà máy trừu tượng và Phương thức nhà máy mà người tạo cho cái trước là Giao diện và người tạo cho cái sau là Class?

Câu hỏi này không còn giá trị, theo các câu trả lời ở trên; tuy nhiên, nếu bạn nghĩ rằng sự khác biệt duy nhất giữa Tóm tắt Nhà máy và Phương thức Nhà máy là số lượng sản phẩm được tạo, hãy xem xét cách khách hàng tiêu thụ từng mẫu này. Một Nhà máy Trừu tượng thường được tiêm vào máy khách của nó và được gọi thông qua thành phần / ủy quyền. Một phương pháp nhà máy phải được kế thừa. Vì vậy, tất cả trở lại với các thành phần cũ so với tranh luận về thừa kế.

Nhưng những câu trả lời này đã đưa ra một câu hỏi thứ tư!

4. Vì, một giao diện chỉ có một phương thức không thể là Phương thức xuất xưởng , ngoài giao diện có thể là một Nhà máy trừu tượng , chúng ta gọi giao diện sáng tạo chỉ có một phương thức là gì?

Nếu phương thức là tĩnh, nó thường được gọi là Nhà máy tĩnh . Nếu phương thức này không tĩnh, nó thường được gọi là Nhà máy đơn giản . Cả hai đều không phải là mẫu GoF, nhưng trong thực tế, chúng được sử dụng phổ biến hơn nhiều!

Theo tôi, sự khác biệt nhỏ giữa hai mẫu nằm ở khả năng ứng dụng , và như vậy, như đã nói, trong Ý định .

Hãy tóm tắt lại các định nghĩa (cả hai từ Wikipedia).

Nhà máy trừu tượng

Cung cấp một giao diện để tạo các họ của các đối tượng liên quan hoặc phụ thuộc mà không chỉ định các lớp cụ thể của chúng.

Phương pháp nhà máy

Xác định một giao diện để tạo một đối tượng , nhưng hãy để các lớp thực hiện giao diện quyết định lớp nào sẽ khởi tạo . Phương thức Factory cho phép khởi tạo lớp trì hoãn cho các lớp con.

Cả hai mẫu cho phép tách rời các đối tượng người dùng khỏi việc tạo các cá thể cần thiết (tách rời thời gian chạy) và đây là khía cạnh phổ biến. Cả hai mẫu cho phép tạo ra một hệ thống phân cấp của các nhà máy theo bất kỳ nhu cầu cụ thể nào, và đây là một khía cạnh phổ biến khác.

Tóm tắt Factory cho phép tạo một số loại phiên bản khác nhau trong một lớp con và để cụ thể hóa hành vi sáng tạo trong các lớp con khác nhau của nó; thông thường, phương thức Factory tuyên bố việc tạo ra chỉ một loại đối tượng có thể được cụ thể hóa theo cơ chế phân lớp. Đó là sự khác biệt.

Bằng cách tóm tắt. Giả sử Sản phẩm định nghĩa siêu hạng của các đối tượng tạo và ProductA và ProductB là hai lớp con khác nhau. Do đó, phương thức Tóm tắt của Nhà máy sẽ có hai phương thức, tạo ProducttA () và tạo ProducttB () sẽ được cụ thể hóa (theo các bước tạo) trong các lớp con cụ thể của nó: các lớp con của nhà máy cụ thể hóa các bước tạo cho hai lớp được xác định của các đối tượng được tạo ra.

Theo ví dụ trên, Phương thức nhà máy sẽ được triển khai theo cách khác, trừu tượng hóa việc tạo ProductA và ProductB ở nhiều nhà máy (một phương pháp cho mỗi Nhà máy) và việc chuyên môn hóa thêm các bước tạo sẽ được giao cho phân cấp khi được xây dựng .

Nếu tôi đã tạo một lớp trừu tượng (được tham chiếu qua giao diện hoặc lớp cơ sở trừu tượng) Lớp Factory tạo các đối tượng chỉ có một phương thức để tạo đối tượng, thì đó sẽ là Phương thức Factory .

Nếu Nhà máy trừu tượng có nhiều hơn 1 phương thức để tạo các đối tượng, thì đó sẽ là Nhà máy Trừu tượng .

Giả sử tôi tạo Trình quản lý sẽ xử lý các nhu cầu của phương thức hành động cho bộ điều khiển MVC. Nếu nó có một phương thức, giả sử tạo các đối tượng động cơ sẽ được sử dụng để tạo các mô hình khung nhìn, thì đó sẽ là một mẫu phương thức nhà máy. Mặt khác, nếu nó có hai phương thức: một để tạo các công cụ mô hình xem và một phương thức để tạo các công cụ mô hình hành động (hoặc bất cứ điều gì bạn muốn gọi mô hình mà phương thức hành động chứa người tiêu dùng), thì đó sẽ là một nhà máy trừu tượng.

public ActionResult DoSomething(SpecificActionModel model)
{
    var actionModelEngine = manager.GetActionModelEngine<SpecificActionModel>();
    actionModelEngine.Execute(SpecificActionModelEnum.Value);

    var viewModelEngine = manager.GetViewModelEngine<SpecificViewModel>();
    return View(viewModelEngine.GetViewModel(SpecificViewModelEnum.Value);
}

Mặc dù, đã nhiều năm kể từ khi mọi người từ StackOverflow đặt câu hỏi về vấn đề này tương tự trong các bài đăng khác (cũ nhất đến năm 2009), tôi vẫn không thể tìm thấy câu trả lời mình muốn.

• Sự khác nhau giữa mô hình nhà máy trừu tượng và phương pháp nhà máy
• Sự khác biệt cơ bản giữa các mô hình nhà máy và nhà máy trừu tượng là gì?

Vì vậy, tôi đã làm một vài giờ nghiên cứu qua web, xem xét các ví dụ và đi đến kết luận này, sự khác biệt chính của Tóm tắt Nhà máy từ Phương thức Nhà máy là

• Ý định: sự gắn kết hoặc "giao diện" : Ý định của Tóm tắt Factory là tập hợp một gia đình các đối tượng có cùng kiểu dáng (ví dụ: các widget UI có giao diện giống nhau, các bộ phận xe hơi cùng kiểu, các đối tượng trong cùng một hệ điều hành, v.v.) Nhiều ví dụ từ Tóm tắt Factory đề cập đến cụm từ chính "cùng một giao diện".
• Các đối tượng hình thành một đối tượng nhóm lớn hơn : Tóm tắt Factory tạo ra một họ các đối tượng tạo thành một đối tượng nhóm lớn hơn, không phải là một đối tượng.
• Sau đó thêm một kiểu mới : Nếu chúng ta tiếp tục sử dụng Phương thức nhà máy và cố gắng thêm một bộ kiểu mới vào cơ sở hạ tầng hiện có, điều đó sẽ gây đau đớn. Với Tóm tắt Factory, tất cả những gì chúng ta chỉ cần làm chỉ đơn giản là tạo ra một nhà máy bê tông mới thực hiện lớp nhà máy trừu tượng.

Các ví dụ truy cập sẽ là

• Một bộ phận xe hơi cho xe thể thao được sử dụng trong một chiếc xe hơi. Sự không nhất quán này có thể dẫn đến tai nạn.
• Nút kiểu Windows trong các tiện ích GUI OS khác nhau. Nó sẽ không phá vỡ bất cứ điều gì ngoài việc làm tổn thương trải nghiệm người dùng đối với một số người, như tôi.
• Sau đó, chúng tôi phát hiện ra rằng phần mềm của chúng tôi cần chạy trong bản nâng cấp HĐH tiếp theo, cần các bộ đối tượng hệ thống tương thích khác nhau trong khi vẫn giữ phần mềm tương thích ngược.

Do đó, khi một nhóm đối tượng cuối cùng có cùng kiểu mà không có ngoại lệ của một đối tượng và bạn muốn ẩn chi tiết "giữ nguyên kiểu này", thì chúng ta nên sử dụng Tóm tắt Factory.

Theo như tôi hiểu ý nghĩa o Tóm tắt phương thức Factory và Factory, định nghĩa đầu tiên được thực hiện trong bối cảnh tĩnh và cung cấp đối tượng dựa trên các tham số đầu vào.

Thứ hai sử dụng đối tượng đã được tạo (họ) thực hiện giao diện phương thức nhà máy. Phương thức nhà máy sau đó tạo ra cá thể cụ thể liên quan đến đối tượng ban đầu cho dù đó là đối tượng nào.

Vì vậy, điều này thường dẫn đến việc sử dụng cả hai mẫu với nhau trong bước đầu tiên bạn tạo một số đối tượng chung mô tả họ các đối tượng liên quan. Nó được gọi bằng phương thức tĩnh getInstance ("tên gia đình tôi"). Việc thực hiện phương thức getInstance như vậy quyết định đối tượng gia đình nào sẽ được tạo.

Sau đó, tôi gọi phương thức create SẢNt () trên đối tượng gia đình mới được tạo và tùy thuộc vào đối tượng gia đình, sản phẩm mới sẽ được trả về.

Dường như những mô hình hợp tác với từng người.

Nói cách khác, Tóm tắt Factory Factory tập trung vào "CÁI GÌ" sẽ được tạo và phương thức Factory "CÁCH" sẽ được tạo.

Tất cả bạn phải nhớ là một nhà máy trừu tượng là một nhà máy có thể trả lại nhiều nhà máy . Vì vậy, nếu bạn có AnimalSpeciesFactory, nó có thể trả về các nhà máy như thế này:

Mamalfactory, BirdFactory, Fishfactory, ReptileFactory. Bây giờ bạn có một nhà máy duy nhất từ ​​AnimalSpeciesFactory, họ sử dụng mô hình nhà máy để tạo ra các phản đối cụ thể. Ví dụ, hãy tưởng tượng bạn có ReptileFactory từ AnimalFactory này, sau đó bạn có thể đề nghị tạo các đối tượng bò sát như: Rắn, rùa, các đối tượng thằn lằn.

/*
//Factory methods:

//1. Factory Method - Abstract Creator Class



#include <iostream>
#include <string.h>
using namespace std;

const std::string nineNintyCC = std::string("990CC");
const std::string thousandTwoHundredCC = std::string("1200CC");
const std::string ThousandFiveHundredCC = std::string("1500CC");
const std::string fiveThousandCC = std::string("5000CC");

// Product
class Engine
{
    public:
    virtual void packEngine() = 0;  
};

// Concrete products
// concrete product class one
class C990CCEngine: public Engine
{

    public:
    void packEngine()
    {
       cout << "Pack 990CC engine" << endl;   
    }
};

// concrete class Two
class C1200CCEngine: public Engine
{   public:
    void packEngine()
    {
        cout << "pack 1200CC engine" << endl;
    }

};

// Concrete class Three
class C1500CCEngine: public Engine
{
    public:
    void packEngine()
    {
        cout << "Pack 1500CC engine" << endl;
    }

};


// Car Factory:
class CarFactory{
    public:

    virtual Engine* createEngine(const std::string& type) = 0;
};
class Factory: public CarFactory
{
    public:
     Engine *createEngine(const std::string& type)
     {

          if(0 == nineNintyCC.compare(type))
          {    
             return new C990CCEngine;
          }
          else if(0 == thousandTwoHundredCC.compare(type))
          {
             return new C1200CCEngine;
          }
          else if(0 == ThousandFiveHundredCC.compare(type))
          {
             return new C1500CCEngine;
          } 
          else
           {
                 cout << "Invalid factory input" << endl;
             return NULL;
           }
           return NULL;
     }
};

int main()
{

    CarFactory* ptr = new Factory;
    Engine*pEngine =  ptr->createEngine(nineNintyCC);
    if(pEngine)
    {
        pEngine->packEngine();
        delete pEngine;
    }
    else
    {
        cout << "No engine exists of your type in our factory" << endl;
    }
    pEngine =  ptr->createEngine(ThousandFiveHundredCC);
    if(pEngine)
    {
        pEngine->packEngine();
        delete pEngine;
    }
    else
    {
        cout << "No engine exists of your type in our factory" << endl;
    }
    pEngine =  ptr->createEngine(thousandTwoHundredCC);
    if(pEngine)
    {
        pEngine->packEngine();
        delete pEngine;
    }
    else
    {
        cout << "No engine exists of your type in our factory" << endl;
    }
    pEngine = ptr-> createEngine(fiveThousandCC);
    if(pEngine)
    {
        pEngine->packEngine();
        delete pEngine;
    }
    else
    {
        cout << "No engine exists of your type in our factory" << endl;
    }
    return 0;
}

*/
/*
//
// interface product
#include <iostream>
#include <string>
using namespace std;

class Engine
{
 public:
 virtual void EngineType() = 0;

};

// concrte product
class AltoEngine: public Engine
{
  public:
  void EngineType()
  {
      cout << "Alto Engine" << endl;
  }
};

//Concrte product
class SwiftEngine : public Engine
{
    public:
    void EngineType()
    {
        cout << "Swift Engine" << endl;    
    }
};

class Body
{
   public:
    virtual void bodyType() = 0;

};

class AltoBody: public Body
{
  public:  
    virtual void bodyType()
    {
        cout << "Alto Car Body" << endl;
    }
};

class SwiftBody : public Body
{
    public:
    void bodyType()
    {
        cout << "SwiftCar Body" << endl;
    }

};


class CarFactory
{
   public:
   virtual Engine* createEngineProduct() = 0;
   virtual Body*   createBodyPoduct() = 0;
};
class AltoCarFactory: public CarFactory
{
    public:
    Engine * createEngineProduct()
    {
        return new AltoEngine;
    }
    Body* createBodyPoduct()
    {
        return new AltoBody;
    }

};

class SwiftCarFactory: public CarFactory
{
    public:
    Engine * createEngineProduct()
    {
        return new SwiftEngine;
    }
    Body* createBodyPoduct()
    {
        return new SwiftBody;
    }

};

int main()
{

    CarFactory* pAltoFactory = new AltoCarFactory;
    Engine* pAltoEngine = pAltoFactory->createEngineProduct();
    pAltoEngine->EngineType();
    Body* pAltoBody = pAltoFactory->createBodyPoduct();
    pAltoBody->bodyType();



    CarFactory* pSwiftFactory = NULL;
    pSwiftFactory = new SwiftCarFactory;
    Engine* pSwiftEngine = pSwiftFactory->createEngineProduct();
    pSwiftEngine->EngineType();
    Body* pSwfitBody = pSwiftFactory->createBodyPoduct();
    pSwfitBody->bodyType();
    delete pAltoBody;
    delete pAltoFactory;
    delete pSwfitBody;
    delete pSwiftFactory;
    return 0;
}
*/

/*

// One more Factory example;

#include <iostream>
#include <string>
using namespace std;

const std::string maruthi = std::string("Maruthi");
const std::string fiat = std::string("Fiat");
const std::string renault = std::string("Renault");
// Interface
class CarEngine
{
 public:
    virtual void engineType() = 0;
};

// Concrete class
class FiatEngine: public CarEngine
{
  public:
  void engineType()
  {
      cout << "Fait Engine Engine" << endl;
  }

};
// ConcreteClass
class RenaultEngine : public CarEngine
{
    public:
    void engineType()
    {
        cout << "Renault Engine" << endl;
    }

};
// Concrete class
class MaruthiEngine : public CarEngine
{
    public:
    void engineType()
    {
        cout << "Maruthi Engine" << endl;
    }
};


// Factory
class CarFactory
{
    public:
    virtual CarEngine* createFactory(const std::string&) = 0;
};

// EngineFactory
class CarEngineFactory : public CarFactory
{
     public:
     CarEngine* createFactory(const std::string&  type)
     {
          if(0 == maruthi.compare(type))
          {
              return new MaruthiEngine;

          }
          else if(0 == fiat.compare(type))
          {
              return  new FiatEngine;
          }
          else if(0 == renault.compare(type))
          {
              return new RenaultEngine;
          }
          else
          {
              cout << "Invalid Engine type" << endl;
              return NULL;
          }
     }

  };

int main()
{
    CarFactory* pCarFactory = new CarEngineFactory;
    CarEngine* pMaruthiCarEngine = pCarFactory->createFactory(maruthi);
    pMaruthiCarEngine->engineType();

    CarEngine* pFiatCarEngine = pCarFactory->createFactory(fiat);
    pFiatCarEngine->engineType();


    CarEngine* pRenaultCarEngine = pCarFactory->createFactory(renault);
    pRenaultCarEngine->engineType();

    return 0;
}


*/


/*

// One more Factory example;

#include <iostream>
#include <string>
using namespace std;

const std::string maruthi = std::string("Maruthi");
const std::string fiat = std::string("Fiat");
const std::string renault = std::string("Renault");


// Interface
class CarEngine
{
 public:
    virtual void engineType() = 0;
};

// Concrete class
class FiatEngine: public CarEngine
{
  public:
  void engineType()
  {
      cout << "Fait Car Engine" << endl;
  }

};

// ConcreteClass
class RenaultEngine : public CarEngine
{
    public:
    void engineType()
    {
        cout << "Renault Car Engine" << endl;
    }

};

// Concrete class
class MaruthiEngine : public CarEngine
{
    public:
    void engineType()
    {
        cout << "Maruthi Car Engine" << endl;
    }
};

// Interface
class CarBody
{
 public:
    virtual void bodyType() = 0;
};

// Concrete class
class FiatBody: public CarBody
{
  public:
  void bodyType()
  {
      cout << "Fait car Body" << endl;
  }

};

// ConcreteClass
class RenaultBody : public CarBody
{
    public:
    void bodyType()
    {
        cout << "Renault Body" << endl;
    }

};

// Concrete class
class MaruthiBody : public CarBody
{
    public:
    void bodyType()
    {
        cout << "Maruthi body" << endl;
    }
};


// Factory
class CarFactory
{
    public:
    virtual CarEngine* createCarEngineProduct() = 0;
    virtual CarBody* createCarBodyProduct() = 0;
};

// FiatFactory
class FaitCarFactory : public CarFactory
{
     public:
     CarEngine* createCarEngineProduct()
     {
        return new FiatEngine; 
     }
     CarBody* createCarBodyProduct()
     {
         return new FiatBody;
     }
};

// Maruthi Factory
class MaruthiCarFactory : public CarFactory
{
     public:
     CarEngine* createCarEngineProduct()
     {
         return new MaruthiEngine;
     }
     CarBody* createCarBodyProduct()
     {
         return new MaruthiBody;
     }

};

// Renault Factory
class RenaultCarFactory : public CarFactory
{
     public:
    CarEngine* createCarEngineProduct()
    {
        return new RenaultEngine;
    }

    CarBody* createCarBodyProduct()
    {
        return new RenaultBody;
    }

};


int main()
{

   // Fiat Factory
   CarFactory* pFiatCarFactory = new FaitCarFactory;
   CarEngine* pFiatEngine = pFiatCarFactory->createCarEngineProduct();
   CarBody*  pFiatBody = pFiatCarFactory->createCarBodyProduct();
   pFiatEngine->engineType();
   pFiatBody->bodyType();

   // Renault Car Factory
    return 0;
}

*/

Mẫu phương thức Factory là một mẫu thiết kế sáng tạo liên quan đến việc tạo các đối tượng mà không hiển thị lớp đối tượng chính xác đang được tạo. Mẫu thiết kế này về cơ bản cho phép một lớp trì hoãn việc khởi tạo đến các lớp con.

Mẫu Tóm tắt của Nhà máy phục vụ đóng gói cho một nhóm các nhà máy riêng lẻ mà không để lộ các lớp cụ thể. Trong mô hình này, một giao diện chung của một lớp nhà máy trừu tượng được sử dụng để tạo ra đối tượng cụ thể cần thiết tách biệt các chi tiết thực hiện của các đối tượng khỏi cách sử dụng và thành phần của chúng. Mẫu thiết kế này được sử dụng rộng rãi trong các ứng dụng GUI trong đó loại thành phần GUI tương tự cần được tạo.

Trong khi tìm kiếm trên google, tôi đã xuất hiện sau blog giải thích cả hai mẫu thiết kế một cách xuất sắc. có một cái nhìn về những

http://simpletechtalks.com/factory-design-potype/

http://simpletechtalks.com/abab-factory-design-potype/