Tasarım Desenleri: Soyut Fabrika vs Fabrika Yöntemi

Not: Sorular yazının sonunda.

Abstract Factory vs Factory Method ile ilgili diğer stackoverflow konularını okudum . Her modelin amacını anlıyorum. Ancak, tanım konusunda net değilim.

Fabrika Yöntemi, bir nesne oluşturmak için bir arabirim tanımlar, ancak alt sınıfların hangilerinin somutlaştırılacağına karar vermesine izin verir. Fabrika yöntemi, sınıfların örneklemeyi alt sınıflara ertelemesini sağlar.

Buna karşılık, bir Soyut Fabrika, somut sınıflarını belirtmeden ilgili veya bağımlı nesnelerin ailelerini oluşturmak için bir arayüz sağlar.

- John Feminella

Özet Fabrika çok benziyor Fabrika Yöntemi . Demek istediğimi göstermek için birkaç UML sınıfı çizdim.

Not:

• Diyagram www.yuml.com adresinden alınmıştır, bu yüzden mükemmel bir şekilde yönlendirilmemişlerdir. Ama onun ücretsiz bir hizmet :).
• Diyagramlar mükemmel olmayabilir. Halen GoF tasarım modellerini öğreniyorum .

Fabrika Yöntemi:

Soyut Fabrika (sadece 1 üye):

Abstract Factory (daha fazla üye):

Sorular:

1. Eğer Özet Fabrika tek yaratıcısı ve bir ürünü var, hala öyle Özet Fabrika desen? (famil oluşturmak için bir arayüz)
2. Can Fabrika Yöntemi beton yaratıcısı bir Arayüz oluşturulabilir ya da bir sınıftan olmak zorunda ki? (sınıflar örneklerin alt sınıflara ertelenmesine neden olur)
3. Eğer Soyut Fabrikanın sadece bir yaratıcısı ve bir ürünü olabilirse, Soyut Fabrika ile Fabrika Yöntemi arasındaki tek fark , birincinin yaratıcısının Arayüz ve ikincisinin yaratıcısının bir Sınıf olmasıdır?

Bu yardımcı olur umarım. Çeşitli fabrika türlerini açıklar. Referans olarak Head First Design Patterns'i kullandım . Diyagram için yuml.me kullandım .

Statik Fabrika

Çeşitli alt Ürün türlerini üretmek için Statik Yöntemli bir sınıftır.

Basit Fabrika

Çeşitli alt ürün türlerini üretebilen bir sınıftır. (Statik Fabrikadan daha iyidir. Yeni tipler eklendiğinde, temel Ürün sınıfının sadece Basit Fabrika Sınıfının değiştirilmesi gerekmez)

Fabrika Yöntemi

Türü ile ilgili bir ürün türü üretmek için bir yöntem içerir. (Tür bir alt sınıfa ertelendiği için Basit Fabrikadan daha iyidir.)

Soyut Fabrika

İlişkili bir Tür Ailesi üretir. Ürettiği birden fazla tip yöntemine sahip olduğu için bir Fabrika Yönteminden belirgin şekilde farklıdır. (Bu karmaşıktır, daha iyi gerçek yaşam örneği için bir sonraki şemaya bakın).

.NET Framework'ten Örnek

DbFactoriesProvider, alt türleri olmadığı için Basit bir Fabrika. DbFactoryProvider, bağlantı ve komut nesneleri gibi çeşitli ilgili veritabanı nesneleri oluşturabildiği için soyut bir fabrikadır.

İki model kesinlikle birbiriyle ilişkilidir!

Desenler arasındaki fark genellikle niyettedir.

Niyet ve Fabrika Yöntemi "bir nesneyi oluşturmak için bir arabirim tanımlamak, ancak alt sınıfları Fabrika Yöntemi alt sınıflar için sınıf erteleme örnekleme sağlayan örneğini hangi sınıfı. Karar versin." Dir

Niyet arasında Özet Fabrikası "somut sınıfları belirtmeden ilişkili ya da bağlı nesnelerin aileleri oluşturmak için bir arabirim sağlar." Olduğu

Sadece bu niyet beyanlarına dayanarak (GoF'den alıntılanmıştır), aslında Fabrika Metodunun bir anlamda bir aileden oluşan "yozlaşmış" bir Soyut Fabrika olduğunu söyleyebilirim .

Fabrika Yöntemi Soyut Fabrikadan daha basit olduğundan , genellikle uygulamada farklılık gösterirler .

Ancak bunlar uygulamada da ilişkilidir. GoF kitabında belirtildiği gibi,

AbstractFactory yalnızca ürün oluşturmak için bir arayüz ilan eder. Bunları gerçekten oluşturmak BetonProduct alt sınıflarına kalmış. Bunu yapmanın en yaygın yolu, her ürün için bir fabrika yöntemi tanımlamaktır.

Bu c2 wiki'nin de bu konuda bazı ilginç tartışmaları var.

OP'nin (mükemmel) sorular listesinin göz ardı edildiği görülüyor. Şu anki cevaplar sadece yeniden tanımlanmış tanımlamalar sunuyor. Bu yüzden orijinal soruları kısaca ele almaya çalışacağım.

1. Eğer Özet Fabrika tek yaratıcısı ve bir ürünü var, hala öyle Özet Fabrika desen? (famil oluşturmak için bir arayüz)

Hayır . Bir Özet Fabrika gerekir bir "ilgili ürünlerin ailesini" yapmak için birden fazla ürün oluşturun. Standart GoF örneği ScrollBar()ve oluşturur Window(). Avantaj (ve amaç), Soyut Fabrikanın birden fazla ürününde ortak bir tema uygulayabilmesidir.

2. Can Fabrika Yöntemi beton yaratıcısı bir Arayüz oluşturulabilir ya da bir sınıftan olmak zorunda ki? (sınıflar örneklerin alt sınıflara ertelenmesine neden olur)

İlk olarak, GoF kitaplarını yazarken ne Java'nın ne de C #'ın olmadığını not etmeliyiz. Arayüz teriminin GoF kullanımı, belirli diller tarafından sunulan arayüz türleriyle ilişkisizdir. Bu nedenle, somut yaratıcı herhangi bir API'dan oluşturulabilir. Modeldeki önemli nokta, API'nin kendi Fabrika Metodunu tüketmesidir, bu nedenle sadece tek bir metoda sahip bir arayüz, bir Soyut Fabrikadan daha fazla bir Fabrika Metodu olamaz.

3. Eğer Soyut Fabrikanın sadece bir yaratıcısı ve bir ürünü olabilirse, Soyut Fabrika ile Fabrika Yöntemi arasındaki tek fark , birincinin yaratıcısının Arayüz ve ikincisinin yaratıcısının bir Sınıf olmasıdır?

Bu soru, yukarıdaki cevapları takiben artık geçerli değil; ancak, Soyut Fabrika ve Fabrika Yöntemi arasındaki tek farkın yaratılan ürün sayısı olduğunu düşünüyorsanız, bir müşterinin bu kalıpların her birini nasıl tükettiğini düşünün. Bir Soyut Fabrika tipik olarak müşterisine enjekte edilir ve kompozisyon / temsilci seçme yoluyla çağrılır. Bir Fabrika Yöntemi miras alınmalıdır. Yani her şey eski kompozisyona ve miras tartışmasına geri dönüyor.

Ancak bu cevaplar dördüncü bir soruyu gündeme getirdi!

4. Beri tek yöntemi ile bir arayüz olamaz Fabrika Yöntem artık bir olabilir daha Özet Fabrika , sadece bir yöntemle bir yaradılış arayüz diyorsunuz ne var?

Yöntem statikse , yaygın olarak Statik Fabrika olarak adlandırılır . Yöntem statik değilse, buna genellikle Basit Fabrika denir . Bunların hiçbiri bir GoF kalıbı değildir, ancak pratikte çok daha yaygın olarak kullanılırlar!

Benim düşünceme göre, iki örüntü arasındaki ufak fark uygulanabilirlikte ve dolayısıyla daha önce de belirtildiği gibi Niyette yatmaktadır .

Tanımları yeniden özetleyelim (her ikisi de Wikipedia'dan).

Soyut Fabrika

Somut sınıflarını belirtmeden ilgili veya bağımlı nesnelerin ailelerini oluşturmak için bir arayüz sağlayın .

Fabrika Yöntemi

Nesne oluşturmak için bir arabirim tanımlayın , ancak arabirimi uygulayan sınıfların hangi sınıfı başlatacağına karar vermesine izin verin . Fabrika yöntemi, bir sınıfın alt sınıflara örnek oluşturmayı ertelemesini sağlar.

Her iki desen de kullanıcı nesnelerinin gerekli örnekleri oluşturmasını (çalışma zamanı ayrıştırması) ayırmasına izin verir ve bu ortak bir özelliktir. Her iki desen de herhangi bir özel ihtiyaca göre fabrikalar hiyerarşisi oluşturmaya izin verir ve bu başka bir ortak özelliktir.

Abstract Factory, bir alt sınıfta birkaç farklı türde örnek oluşturmaya ve farklı alt sınıflarında yaratım davranışını özelleştirmeye izin verir; normalde Fabrika yöntemi, alt sınıflandırma mekanizmasına göre özelleştirilebilen yalnızca bir tür nesnenin oluşturulduğunu bildirir. Aradaki fark bu.

Özetleyerek. Diyelim ki Ürün, yaratılan nesnelerin süper sınıfını tanımlar ve ProductA ve ProductB iki farklı alt sınıftır. Bu nedenle, Abstract Factory yönteminin iki alt yöntemi olacaktır: createProductA () ve createProductB (), kendi alt sınıflarında belirtilecek (oluşturma adımları açısından): fabrika alt sınıfları , tanımlanan iki sınıf için oluşturma adımlarını özelleştirir yaratılan nesnelerin.

Yukarıdaki örneğe göre, Fabrika Yöntemi farklı bir şekilde uygulanacak ve birçok fabrikada (Fabrika başına bir yöntem) ProductA ve ProductB'nin oluşturulmasını soyutlayacak ve oluşturma adımlarının daha fazla uzmanlaşması inşa edildiğinde hiyerarşiye devredilecektir. .

Nesneleri oluşturmak için yalnızca bir yöntemi olan nesneler oluşturan soyutlanmış (bir arabirim veya soyut temel sınıf aracılığıyla başvurulur) Factory Class oluşturduysam, bu bir Fabrika Yöntemi olacaktır .

Eğer soyutlanmış fabrikada nesneler yaratmak için 1'den fazla yöntem varsa, o zaman bir soyut fabrika olurdu .

Bir MVC denetleyicisi için eylem yöntemlerinin ihtiyaçlarını karşılayacak bir Yönetici yaptığımı varsayalım. Tek bir yöntemi varsa, görünüm modelleri oluşturmak için kullanılacak motor nesnelerini oluşturmayı varsa, bu bir fabrika yöntemi kalıbı olacaktır. Öte yandan, iki yöntem varsa: biri görünüm modeli motorları oluşturmak için diğeri ise eylem modeli motorları oluşturmak için (veya eylem yönteminin tüketicileri içerdiği modeli çağırmak istediğiniz her şey), o zaman soyut bir fabrika olacaktır.

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'dan gelen insanlar bu konuda diğer yazılarda da benzer şekilde sorgulandığından beri uzun yıllar geçmesine rağmen (2009'un en eskisi), hala istediğim cevabı bulamadım.

• Soyut Fabrika Deseni ve Fabrika Yöntemi Arasındaki Farklar
• Fabrika ve Soyut Fabrika Kalıpları arasındaki temel fark nedir?

Web üzerinden birkaç saat araştırma yaptım, örnekleri gözden geçirdim ve bu sonuca vardım, Soyut Fabrikanın Fabrika Yönteminden önemli farklılıkları

• Amaç: tutarlılık veya "görünüm ve his" : Özet Fabrika'nın amacı, aynı stile sahip bir nesne ailesini gruplandırmaktır (örneğin, aynı görünüm ve his UI widget'ları, aynı stil araba parçaları, aynı işletim sisteminden nesneler, vs.) Abstract Factory'den birçok örnek "aynı görünüm ve his" anahtar ifadesinden bahseder.
• Daha büyük bir grup nesnesi oluşturan nesneler : Abstract Factory, tek bir nesne değil, daha büyük bir grup nesnesi oluşturan bir nesne ailesi oluşturur.
• Daha sonra yeni bir stil ekleyin : Fabrika Yöntemi'ni kullanmaya devam edersek ve mevcut altyapıya yeni bir stil seti eklemeye çalışırsak, bu acı verici olurdu. Abstract Factory ile tek yapmamız gereken, soyut fabrika sınıfını uygulayan yeni bir beton fabrikası yaratmak.

Karşı örnekler

• Bir sedan kullanılan spor otomobil için bir araba parçası. Bu tutarsızlık kazalara yol açabilir.
• Farklı OS GUI widget'larındaki Windows stili bir düğme. Benim gibi bazı insanlar için kullanıcı deneyimini incitmekten başka bir şey kırmayacak.
• Daha sonra, yazılımımızı geriye dönük olarak uyumlu tutarken bir dizi uyumlu sistem nesnesi gerektiren bir sonraki işletim sistemi yükseltmesinde çalışması gerektiğini öğreniyoruz.

Bu nedenle, bir son nesne grubunun bir nesne istisnasız aynı stile sahip olması ve bu "aynı stili koruyarak" detayını gizlemek istediğinizde, Abstract Factory kullanmalıyız.

Soyut fabrika ve fabrika yöntem tanımlarının anlamını anladığım kadarıyla ilki statik bağlamda uygulanır ve girdi parametrelerine dayalı nesne sağlar.

İkincisi, fabrika yöntemi arabirimini uygulayan önceden oluşturulmuş nesneyi (aile) kullanır. Daha sonra fabrika yöntemi, hangisi olursa olsun orijinal nesne ile ilgili özel bir örnek oluşturur.

Bu, genellikle her iki deseni birlikte kullanmaya yol açar, burada ilk adımda ilgili nesnelerin ailesini tanımlayan genel bir nesne yaratırsınız. Statik yöntem getInstance ("ailemin adı") yöntemiyle çağrılır. Bu getInstance yönteminin uygulanması, hangi aile nesnesinin oluşturulacağına karar verir.

Sonra yeni oluşturulan aile nesnesinde createProduct () yöntemini çağırıyorum ve aile nesnesine bağlı olarak yeni ürün iade edilecektir.

Bu kalıpların her biri ile işbirliği yaptığı görülmektedir.

Başka bir deyişle Soyut Fabrika "NE" yaratılacak ve Fabrika metodu "NASIL" yaratılacak.

Hatırlamanız gereken tek şey, soyut bir fabrikanın birden fazla fabrikayı iade edebilen bir fabrika olduğudur . Eğer bir AnimalSpeciesFactory'niz varsa, bu tür fabrikaları iade edebilir:

Mamalfactory, BirdFactory, Fishfactory, Sürüngen Fabrikası. Artık AnimalSpeciesFactory'den tek bir fabrikaya sahip olduğunuza göre, bunlar belirli objeksler oluşturmak için fabrika modelini kullanıyorlar. Örneğin, bu AnimalFactory'den bir ReptileFactory'niz olduğunu hayal edin, sonra Yılanlar, kaplumbağalar, kertenkeleler nesneleri gibi sürüngen nesneleri oluşturmayı önerebilirsiniz.

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

*/

Fabrika yöntemi kalıbı, yaratılan nesnenin tam sınıfını göstermeden nesne oluşturmayla ilgilenen yaratıcı bir tasarım modelidir. Bu tasarım deseni temelde bir sınıfın alt sınıflara örneklemeyi savunmasına izin verir.

Soyut Fabrika modeli, somut sınıfları ortaya çıkarmadan bir grup münferit fabrikanın kapsüllenmesine hizmet eder. Bu modelde, soyut bir fabrika sınıfının genel bir arayüzü, nesnelerin uygulama detaylarını kullanımlarından ve kompozisyonlarından ayıran gerekli somut nesneyi oluşturmak için kullanılır. Bu tasarım deseni, benzer türde GUI bileşenlerinin oluşturulması gereken GUI uygulamalarında yaygın olarak kullanılmaktadır.

google üzerinde arama yaparken ben de her iki tasarım deseni parlak açıkladı blog takip geldi. bunlara bir göz at

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

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