디자인 패턴 : 추상 팩토리 vs 팩토리 메소드

참고 : 질문은 게시물 끝에 있습니다.

Abstract Factory vs Factory Method 에 관한 다른 stackoverflow 스레드를 읽었습니다 . 각 패턴의 의도를 이해합니다. 그러나 나는 그 정의에 대해 명확하지 않다.

팩토리 메소드는 객체를 만들기위한 인터페이스를 정의하지만 서브 클래스에서 인스턴스화 할 인터페이스를 결정할 수 있습니다. 팩토리 메소드는 클래스가 인스턴스화를 서브 클래스로 연기하도록합니다.

반대로 Abstract Factory는 구체적인 클래스를 지정하지 않고 관련 또는 종속 객체의 패밀리를 작성하기위한 인터페이스를 제공합니다.

- 존 페미 넬라

추상 공장 받는 매우 비슷 공장 방법 . 요점을 설명하기 위해 몇 가지 UML 클래스를 그렸습니다.

노트 :

• 이 다이어그램은 www.yuml.com 에서 제공 되므로 완벽하게 지향되지는 않습니다. 그러나 무료 서비스 :).
• 다이어그램이 완벽하지 않을 수 있습니다. 나는 여전히 GoF 디자인 패턴을 배우고 있습니다.

공장 방법 :

초록 팩토리 (멤버 1 명만) :

초록 공장 (더 많은 회원) :

질문 :

1. 경우 추상 공장은 하나의 창조주와 하나 개의 제품을 가지고, 여전히입니다 추상 팩토리 패턴? (패밀리를 만들기위한 인터페이스)
2. 캔 공장 방법 콘크리트 작성자는 인터페이스에서 만들 수 또는 클래스에서해야합니까? (클래스는 서브 클래스로 인스턴스화를 지연시킵니다)
3. Abstract Factory가 하나의 작성자와 하나의 제품 만 가질 수있는 경우, Abstract Factory 와 Factory Method 의 유일한 차이점 은 전자의 작성자가 인터페이스이고 후자의 작성자는 클래스라는 것입니까?

도움이 되었기를 바랍니다. 다양한 유형의 공장을 설명합니다. 내가 사용하는 헤드 퍼스트 디자인 패턴을 내 참조한다. yuml.me 를 다이어그램에 사용 했습니다 .

정적 팩토리

다양한 하위 유형의 Product를 생성하기위한 Static Method가있는 클래스입니다.

간단한 공장

다양한 하위 유형의 제품을 생성 할 수있는 클래스입니다. (정적 팩토리보다 낫습니다. 새 유형이 추가되면 기본 Product 클래스는 단순 팩토리 클래스 만 변경할 필요가 없습니다)

공장 방법

해당 유형과 관련된 한 가지 유형의 제품을 생성하는 한 가지 방법이 포함되어 있습니다. 유형이 하위 클래스로 지연되기 때문에 단순 팩토리보다 낫습니다.

추상 공장

관련된 유형 패밀리를 생성합니다. 하나 이상의 생성 유형 유형이 있으므로 팩토리 메소드와 현저히 다릅니다. (이것은 복잡한 실제 예제를 보려면 다음 다이어그램을 참조하면 복잡합니다).

.NET Framework의 예

DbFactoriesProvider는 하위 유형이 없으므로 단순 팩토리입니다. DbFactoryProvider는 연결 및 명령 오브젝트와 같은 다양한 관련 데이터베이스 오브젝트를 작성할 수 있으므로 추상 팩토리입니다.

두 패턴은 확실히 관련이 있습니다!

패턴의 차이는 일반적으로 의도입니다.

의도 의 공장 방법은 "객체를 생성하기위한 인터페이스를 정의하지만, 서브 클래스가 공장 방법이 서브 클래스에 클래스 연기 인스턴스화 할 수 인스턴스화 할 수있는 클래스입니다. 결정하게"입니다.

의도 의 추상 공장 "자신의 구체적인 클래스를 지정하지 않고 관련 또는 종속 객체의 가족을 만들기위한 인터페이스를 제공합니다"입니다.

이러한 의도 진술 (GoF에서 인용)을 기반으로, 실제로 팩토리 메소드 는 어떤 의미에서는 하나의 패밀리를 갖는 "퇴화" 추상 팩토리 라고 말할 수 있습니다.

Factory Method 는 Abstract Factory 보다 훨씬 간단하기 때문에 일반적으로 구현 방식 이 다릅니다 .

그러나 그들은 또한 구현과 관련이 있습니다. GoF 책에서 언급했듯이

AbstractFactory는 제품 생성을위한 인터페이스 만 선언합니다. 실제로 만드는 것은 ConcreteProduct 서브 클래스에 달려 있습니다. 이를 수행하는 가장 일반적인 방법은 각 제품에 대한 팩토리 방법을 정의하는 것입니다.

이 c2 위키 에는이 주제에 대한 흥미로운 토론이 있습니다.

OP의 (우수한) 질문 목록은 무시 된 것 같습니다. 현재 답변은 단지 다시 정의 된 정의를 제공합니다. 그래서 나는 원래의 질문을 간결하게 해결하려고 노력할 것입니다.

1. 경우 추상 공장은 하나의 창조주와 하나 개의 제품을 가지고, 여전히입니다 추상 팩토리 패턴? (패밀리를 만들기위한 인터페이스)

없음 . Abstract Factory 는 "관련 제품 제품군"을 만들려면 둘 이상의 제품을 만들어야합니다. 표준 GoF 예제는 ScrollBar()및을 만듭니다 Window(). Abstract Factory는 여러 제품에서 공통 테마를 적용 할 수 있다는 장점이 있습니다.

2. 캔 공장 방법 콘크리트 작성자는 인터페이스에서 만들 수 또는 클래스에서해야합니까? (클래스는 서브 클래스로 인스턴스화를 지연시킵니다)

먼저, GoF가 책을 쓸 때 Java도 C #도 존재하지 않았다는 점에 유의해야합니다. 인터페이스 라는 용어의 GoF 사용은 특정 언어에 의해 도입 된 인터페이스 유형과 관련이 없습니다. 따라서 콘크리트 제작자는 모든 API에서 만들 수 있습니다. 패턴에서 중요한 점은 API가 자체 팩토리 메소드를 소비한다는 것입니다. 따라서 하나의 메소드 만있는 인터페이스는 팩토리 메소드가 될 수 없으며 추상 팩토리 일 수 없습니다.

3. Abstract Factory가 하나의 작성자와 하나의 제품 만 가질 수있는 경우, Abstract Factory 와 Factory Method 의 유일한 차이점 은 전자의 작성자가 인터페이스이고 후자의 작성자는 클래스라는 것입니까?

위의 답변에 따라이 질문은 더 이상 유효하지 않습니다. 그러나 Abstract Factory와 Factory Method의 유일한 차이점은 생성 된 제품 수라고 생각하는 경우 클라이언트가 이러한 각 패턴을 소비하는 방법을 고려하십시오. 추상 팩토리는 일반적으로 클라이언트에 주입되고 구성 / 위임을 통해 호출됩니다. 팩토리 메소드는 상속되어야합니다. 그래서 그것은 모두 구 작곡과 상속 토론으로 돌아옵니다.

그러나이 답변은 네 번째 질문을 제기했습니다!

4. 이후, 단 하나의 방법 인터페이스가 될 수 없다 공장 방법을 더 이상 그것이 할 수있는 것보다 추상 공장 , 우리는 하나의 방법으로 창조적 인터페이스를 호출 할 무엇?

메소드가 정적이면 일반적으로 정적 팩토리 라고합니다 . 메소드가 정적이 아닌 경우 일반적으로 단순 팩토리 라고합니다 . 이들 중 어느 것도 GoF 패턴은 아니지만 실제로는 훨씬 일반적으로 사용됩니다!

제 생각에 두 패턴 사이의 약간의 차이는 적용 가능성 에 있으며, 이미 언급 했듯이 Intent에도 있습니다.

정의를 요약 해 보겠습니다 (둘 다 Wikipedia에서).

추상 공장

구체적인 클래스를 지정하지 않고 관련 또는 종속 객체의 패밀리 를 작성 하기위한 인터페이스를 제공하십시오 .

공장 방법

정의 객체를 생성하기위한 인터페이스를 하지만, 수 있도록 인터페이스를 구현하는 클래스가 인스턴스화에있는 클래스를 결정합니다 . Factory 메소드는 클래스가 서브 클래스에 대한 인스턴스화를 연기하도록합니다.

두 패턴 모두 사용자 인스턴스를 분리하여 필요한 인스턴스를 생성하지 못하도록합니다 (런타임 디커플링). 이것이 일반적인 측면입니다. 두 패턴 모두 특정 요구에 따라 팩토리 계층을 생성 할 수 있으며 이는 또 다른 일반적인 측면입니다.

Abstract Factory는 하나의 서브 클래스에 여러 유형의 인스턴스를 생성하고 다른 서브 클래스에 생성 동작을 구체화 할 수 있습니다. 일반적으로 Factory 메소드는 서브 클래 싱 메커니즘에 따라 특정 될 수있는 한 가지 유형의 오브젝트 작성 만 선언합니다. 그 차이입니다.

요약해서. Product가 작성 오브젝트의 수퍼 클래스를 정의하고 ProductA와 ProductB가 서로 다른 두 개의 서브 클래스라고 가정하십시오. 따라서 추상 팩토리 메소드에는 특정 서브 클래스에서 특정 될 (생성 단계 측면에서) createProductA () 및 createProductB () 메소드가 있습니다. 팩토리 서브 클래스 는 정의 된 두 클래스에 대한 작성 단계 를 지정합니다. 생성중인 개체의

위의 예에 따르면 팩토리 메소드는 다르게 구현되어 팩토리 당 하나의 메소드로 많은 팩토리에서 ProductA 및 ProductB 작성을 추상화하며, 작성 단계 의 추가 전문화 는 빌드 될 때 계층 구조에 위임됩니다. .

객체를 생성하는 메소드가 하나 뿐인 객체를 생성하는 추상 (인터페이스 또는 추상 기본 클래스를 통해 참조되는) 팩토리 클래스를 생성 한 경우 팩토리 메소드가 됩니다.

추상화 된 팩토리에 객체를 생성하는 방법이 두 개 이상인 경우 추상 팩토리가 됩니다.

MVC 컨트롤러에 대한 조치 방법의 요구를 처리 할 Manager를 작성한다고 가정하겠습니다. 뷰 모델을 생성하는 데 사용될 엔진 객체를 생성하는 방법이 하나 있다면 팩토리 분석법 패턴이됩니다. 반면에 뷰 모델 엔진을 생성하는 방법과 액션 모델 엔진을 생성하는 방법 (또는 액션 방법에 소비자가 포함하는 모델을 호출하려는 방법)의 두 가지 방법이 있다면 추상 팩토리가됩니다.

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);
}

그러나 StackOverflow의 사람들이 다른 게시물 (이전 가장 오래된 2009 년) 에서이 문제에 대해 비슷한 질문을 한 지 몇 년이 지났지 만 여전히 원하는 대답을 찾을 수 없었습니다.

• 추상 팩토리 패턴과 팩토리 메소드의 차이점
• 팩토리 패턴과 추상 팩토리 패턴의 기본 차이점은 무엇입니까?

그래서 웹을 통해 몇 시간 동안 연구하고 예제를 검토 했으며이 결론에 도달했습니다. 공장 방법과 추상 공장의 주요 차이점은

• 의도 : 일관성 또는 "룩앤필" : Abstract Factory의 의도는 동일한 스타일 (예 : 동일한 모양 및 느낌 UI 위젯, 동일한 스타일의 자동차 부품, 동일한 OS의 오브젝트, 등) Abstract Factory의 많은 예제는 "같은 모양과 느낌"이라는 핵심 문구에 대해 언급합니다.
• 더 큰 그룹 객체를 형성하는 객체 : Abstract Factory는 단일 객체가 아닌 더 큰 그룹 객체를 형성하는 객체 패밀리를 만듭니다.
• 나중에 새로운 스타일 추가 : Factory Method를 계속 사용하고 기존 인프라에 새로운 스타일 세트를 추가하려고하면 고통 스러울 것입니다. Abstract Factory를 사용하면 추상 팩토리 클래스를 구현하는 새로운 콘크리트 팩토리를 만들면됩니다.

카운터 예제는

• 세단 형 자동차에 사용되는 스포츠카 용 자동차 부품. 이 불일치는 사고로 이어질 수 있습니다.
• 다른 OS GUI 위젯에있는 Windows 스타일 버튼 그것은 나와 같은 일부 사람들에게는 아무것도 깨뜨리지 않고 사용자 경험을 해칠 것입니다.
• 나중에 소프트웨어는 이전 버전과의 호환성을 유지하면서 서로 다른 호환 가능한 시스템 개체 집합이 필요한 다음 OS 업그레이드에서 소프트웨어를 실행해야합니다.

따라서 최종 객체 그룹이 객체를 제외 하고 동일한 스타일 을 가져야 하고이 "같은 스타일 유지"세부 정보를 숨기려면 Abstract Factory를 사용해야합니다.

초록 팩토리 및 팩토리 메소드 정의의 의미를 이해하는 한 첫 번째는 정적 컨텍스트에서 구현되며 입력 매개 변수를 기반으로 오브젝트를 제공합니다.

두 번째는 팩토리 메소드 인터페이스를 구현하는 이미 작성된 오브젝트 (패밀리)를 사용합니다. 팩토리 메소드는 원본 객체와 관계없이 원본 객체와 관련된 특정 인스턴스를 만듭니다.

따라서 이것은 일반적으로 두 패턴을 함께 사용하여 첫 번째 단계에서 관련 객체 군을 설명하는 일반적인 객체를 만듭니다. 정적 메소드 getInstance ( "my family name") 메소드에 의해 호출됩니다. 이러한 getInstance 메소드의 구현은 작성 될 패밀리 오브젝트를 결정합니다.

그런 다음 새로 작성된 패밀리 오브젝트에서 createProduct () 메소드를 호출하고 패밀리 오브젝트에 따라 새 제품이 리턴됩니다.

이러한 패턴은 서로 협력하는 것으로 보입니다.

다시 말해 Abstract Factory는 "WHAT"에 초점을 맞추고 Factory 메소드 "HOW"에 초점을 맞 춥니 다.

추상 팩토리는 여러 팩토리를 반환 할 수있는 팩토리라는 점만 기억하면 됩니다. 따라서 AnimalSpeciesFactory가 있으면 다음과 같이 팩토리를 리턴 할 수 있습니다.

Mamalfactory, BirdFactory, Fishfactory, 파충류 공장. AnimalSpeciesFactory의 단일 팩토리가 있으므로 팩토리 패턴을 사용하여 특정 objext를 작성합니다. 예를 들어,이 AnimalFactory에서 ReptileFactory를 가지고 있다고 가정하면 뱀, 거북, 도마뱀 개체와 같은 파충류 개체를 만들 수 있습니다.

/*
//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;
}

*/

팩토리 메소드 패턴은 작성중인 오브젝트의 정확한 클래스를 표시하지 않고 오브젝트 작성을 처리하는 작성 설계 패턴입니다. 이 디자인 패턴은 기본적으로 클래스가 인스턴스를 하위 클래스로 연기하는 것을 허용합니다.

Abstract Factory 패턴은 구체적인 클래스를 노출시키지 않고 개별 팩토리 그룹에 캡슐화를 제공합니다. 이 모델에서는 추상 팩토리 클래스의 일반 인터페이스를 사용하여 객체 구현 세부 사항을 사용법 및 구성과 분리하는 필수 콘크리트 객체를 작성합니다. 이 디자인 패턴은 유사한 종류의 GUI 구성 요소를 작성해야하는 GUI 응용 프로그램에서 널리 사용됩니다.

Google에서 검색하는 동안 두 디자인 패턴을 훌륭하게 설명하는 블로그를 따라 나왔습니다. 이것들을 봐

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

http://simpletechtalks.com/abstract-factory-design-pattern/