Pola Desain: Abstrak Pabrik vs Metode Pabrik

Catatan: Pertanyaan ada di akhir pos.

Saya telah membaca utas stackoverflow lainnya mengenai Abstract Factory vs Factory Method . Saya mengerti maksud dari masing-masing pola. Namun, saya tidak jelas tentang definisi itu.

Metode Pabrik mendefinisikan antarmuka untuk membuat objek, tetapi memungkinkan subclass memutuskan yang mana dari mereka untuk instantiate. Metode pabrik memungkinkan kelas menunda instantiation ke subclass.

Sebaliknya, Pabrik Abstrak menyediakan antarmuka untuk membuat keluarga objek terkait atau bergantung tanpa menentukan kelas konkret mereka.

- John Feminella

The Abstrak Pabrik terlihat sangat mirip dengan Pabrik Metode . Saya telah menggambar beberapa kelas UML untuk mengilustrasikan poin saya.

catatan:

• Diagram berasal dari www.yuml.com sehingga tidak berorientasi sempurna. Tapi ini layanan gratis :).
• Diagram mungkin tidak sempurna. Saya masih mempelajari pola desain GoF .

Metode pabrik:

Pabrik Abstrak (hanya 1 anggota):

Pabrik Abstrak (lebih banyak anggota):

Pertanyaan:

1. Jika Pabrik Abstrak hanya memiliki satu pencipta dan satu produk, apakah itu masih merupakan pola Pabrik Abstrak ? (antarmuka untuk membuat famili)
2. Dapatkah pembuat Metode Pabrik dibuat dari Antarmuka atau harus dari kelas? (kelas menunda instantiations ke subclass)
3. Jika Pabrik Abstrak hanya dapat memiliki satu pencipta dan satu produk, apakah satu-satunya perbedaan antara Pabrik Abstrak dan Metode Pabrik bahwa pencipta untuk yang pertama adalah sebuah Antarmuka dan pembuat untuk yang terakhir adalah Kelas?

Semoga ini membantu. Ini menggambarkan berbagai jenis pabrik. Saya menggunakan Head First Design Patterns sebagai referensi saya. Saya menggunakan yuml.me untuk diagram.

Pabrik Statis

Merupakan kelas dengan Metode Statis untuk menghasilkan berbagai sub jenis Produk.

Pabrik Sederhana

Merupakan kelas yang dapat menghasilkan berbagai sub jenis Produk. (Lebih baik daripada Pabrik Statis. Ketika tipe baru ditambahkan, kelas Produk dasar tidak perlu diubah hanya Kelas Pabrik Sederhana)

Metode Pabrik

Berisi satu metode untuk menghasilkan satu jenis produk yang terkait dengan jenisnya. (Ini lebih baik daripada Pabrik Sederhana karena jenisnya ditangguhkan ke sub-kelas.)

Pabrik Abstrak

Menghasilkan Keluarga Jenis yang terkait. Ini sangat berbeda dari Metode Pabrik karena memiliki lebih dari satu metode jenis yang dihasilkannya. (Ini rumit merujuk ke diagram berikutnya untuk contoh kehidupan nyata yang lebih baik).

Contoh Dari .NET Framework

DbFactoriesProvider adalah Pabrik Sederhana karena tidak memiliki sub-tipe. DbFactoryProvider adalah pabrik abstrak karena dapat membuat berbagai objek database terkait seperti objek koneksi dan perintah.

Kedua pola ini tentu terkait!

Perbedaan antara pola-pola ini umumnya ada dalam niat.

The maksud dari Pabrik Metode adalah "Tentukan sebuah antarmuka untuk menciptakan sebuah objek, tetapi biarkan subclass memutuskan mana kelas untuk instantiate. Factory Method memungkinkan Instansiasi kelas defer untuk subclass."

The maksud dari Pabrik Abstrak adalah "Menyediakan sebuah antarmuka untuk menciptakan keluarga dari obyek terkait atau tergantung tanpa menentukan kelas beton mereka."

Berdasarkan murni pada pernyataan niat ini (dikutip dari GoF), saya akan mengatakan bahwa memang Metode Pabrik dalam beberapa hal merupakan Pabrik Abstrak yang "merosot" dengan satu keluarga.

Mereka umumnya cenderung berbeda dalam implementasi, karena Metode Pabrik jauh lebih sederhana daripada Pabrik Abstrak .

Namun mereka terkait juga dalam implementasi. Sebagaimana dicatat dalam buku GoF,

AbstractFactory hanya menyatakan antarmuka untuk membuat produk. Terserah subkelas ConcreteProduct untuk benar-benar membuatnya. Cara paling umum untuk melakukan ini adalah mendefinisikan metode pabrik untuk setiap produk.

Wiki c2 ini juga memiliki beberapa diskusi menarik tentang topik ini.

Tampaknya daftar pertanyaan (luar biasa) OP telah diabaikan. Jawaban saat ini hanya menawarkan definisi yang diulang. Jadi saya akan berusaha menjawab pertanyaan asli dengan singkat.

1. Jika Pabrik Abstrak hanya memiliki satu pencipta dan satu produk, apakah itu masih merupakan pola Pabrik Abstrak ? (antarmuka untuk membuat famili)

Tidak ada . Pabrik Abstrak harus membuat lebih dari satu produk untuk membuat "keluarga produk terkait". Contoh GoF kanonik membuat ScrollBar()dan Window(). Keuntungan (dan tujuan) adalah bahwa Pabrik Abstrak dapat menegakkan tema umum di berbagai produknya.

2. Dapatkah pembuat Metode Pabrik dibuat dari Antarmuka atau harus dari kelas? (kelas menunda instantiations ke subclass)

Pertama, kita harus perhatikan bahwa baik Java maupun C # tidak ada ketika GoF menulis buku mereka. Penggunaan istilah antarmuka oleh GoF tidak terkait dengan jenis antarmuka yang diperkenalkan oleh bahasa tertentu. Oleh karena itu, pembuat beton dapat dibuat dari API apa pun. Poin penting dalam pola adalah bahwa API mengkonsumsi Metode Pabrik sendiri, sehingga antarmuka dengan hanya satu metode tidak dapat menjadi Metode Pabrik seperti halnya Pabrik Abstrak.

3. Jika Pabrik Abstrak hanya dapat memiliki satu pencipta dan satu produk, apakah satu-satunya perbedaan antara Pabrik Abstrak dan Metode Pabrik bahwa pencipta untuk yang pertama adalah sebuah Antarmuka dan pembuat untuk yang terakhir adalah Kelas?

Pertanyaan ini tidak lagi valid, mengikuti jawaban di atas; namun, jika Anda berpikir bahwa satu-satunya perbedaan antara Pabrik Abstrak dan Metode Pabrik adalah jumlah produk yang dibuat, pertimbangkan bagaimana klien mengkonsumsi masing-masing pola ini. Pabrik Abstrak biasanya disuntikkan ke kliennya dan dipanggil melalui komposisi / delegasi. Metode Pabrik harus diwariskan. Jadi semuanya kembali ke perdebatan komposisi vs warisan lama.

Tetapi jawaban ini telah menimbulkan pertanyaan keempat!

4. Karena, antarmuka dengan hanya satu metode tidak dapat menjadi Metode Pabrik seperti halnya Pabrik Abstrak , apa yang kita sebut antarmuka kreatif dengan hanya satu metode?

Jika metode ini statis, biasanya disebut Pabrik Statis . Jika metode ini tidak statis, biasanya disebut Pabrik Sederhana . Tak satu pun dari ini adalah pola GoF, tetapi dalam praktiknya mereka jauh lebih umum digunakan!

Menurut pendapat saya, sedikit perbedaan antara kedua pola terletak pada penerapannya , dan demikian, sebagaimana telah dikatakan, dalam Intent .

Mari rekap definisi (keduanya dari Wikipedia).

Pabrik Abstrak

Menyediakan antarmuka untuk membuat keluarga objek terkait atau bergantung tanpa menentukan kelas konkret mereka.

Metode Pabrik

Tentukan antarmuka untuk membuat objek , tetapi biarkan kelas yang mengimplementasikan antarmuka memutuskan kelas mana yang akan dipakai . Metode Factory memungkinkan class defer instantiation ke subclass.

Kedua pola memungkinkan untuk memisahkan objek pengguna dari membuat instance yang diperlukan (run-time decoupling), dan ini adalah aspek umum. Kedua pola memungkinkan untuk membuat hierarki pabrik sesuai dengan kebutuhan spesifik, dan ini adalah aspek umum lainnya.

Abstrak Factory memungkinkan untuk membuat beberapa jenis instance yang berbeda dalam satu sub-kelas, dan untuk partikularisasi perilaku kreasi dalam sub-kelas yang berbeda; biasanya, metode Pabrik menyatakan penciptaan hanya satu jenis objek yang dapat dikelompokkan menurut mekanisme sub-klasifikasi. Itulah bedanya.

Dengan meringkas. Katakanlah Produk mendefinisikan kelas-super dari objek-objek pembuat, dan ProductA dan ProductB adalah dua sub-kelas yang berbeda. Oleh karena itu, metode Pabrik Abstrak akan memiliki dua metode, createProductA () dan createProductB () yang akan partikularisasi (dalam hal langkah-langkah pembuatan) dalam sub-kelas spesifiknya: sub-kelas pabrik memfokuskan langkah - langkah pembuatan untuk dua kelas yang ditentukan benda yang sedang dibuat.

Menurut contoh di atas, Metode Pabrik akan diimplementasikan secara berbeda, mengabstraksi pembuatan ProductA dan ProductB di banyak pabrik (satu metode per Pabrik), dan spesialisasi lebih lanjut dari langkah - langkah pembuatan akan didelegasikan ke hierarki saat dibangun. .

Jika saya membuat abstrak (direferensikan melalui antarmuka atau kelas dasar abstrak) kelas pabrik yang membuat objek yang hanya memiliki satu metode untuk membuat objek, maka itu akan menjadi metode pabrik .

Jika Pabrik yang diabstraksi memiliki lebih dari 1 metode untuk membuat objek, maka itu akan menjadi Pabrik yang Abstrak .

Katakanlah saya membuat Manajer yang akan menangani kebutuhan metode tindakan untuk pengontrol MVC. Jika memiliki satu metode, katakanlah untuk membuat objek mesin yang akan digunakan untuk membuat model tampilan, maka itu akan menjadi pola metode pabrik. Di sisi lain jika memiliki dua metode: satu untuk membuat mesin model tampilan, dan yang lain untuk membuat mesin model tindakan (atau apa pun yang Anda ingin sebut model yang metode tindakannya berisi konsumen), maka itu akan menjadi pabrik abstrak.

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

Meskipun, sudah bertahun-tahun sejak orang-orang dari StackOverflow mempertanyakan masalah ini dengan cara yang sama di pos-pos lain (terlama hingga 2009), saya masih tidak dapat menemukan jawaban yang saya inginkan.

• Perbedaan antara Pola Pabrik Abstrak dan Metode Pabrik
• Apa perbedaan mendasar antara Pabrik dan Pola Pabrik Abstrak?

Jadi saya melakukan beberapa jam meneliti melalui web, meninjau contoh-contoh, dan sampai pada kesimpulan ini, perbedaan utama Pabrik Abstrak dari Metode Pabrik adalah

• Maksud: koherensi atau "tampilan-dan-rasa" : Abstrak Maksud pabrik adalah untuk mengelompokkan sekelompok objek dengan gaya yang sama (mis. Widget UI tampilan-dan-nuansa yang sama, bagian mobil gaya yang sama, objek dari OS yang sama, dll.) Banyak contoh dari Pabrik Abstrak menyebutkan tentang frasa kunci "tampilan dan rasa yang sama".
• Objek yang membentuk objek grup yang lebih besar : Abstrak Pabrik membuat kumpulan objek yang membentuk objek grup yang lebih besar, bukan objek tunggal.
• Kemudian tambahkan gaya baru : Jika kita terus menggunakan Metode Pabrik dan mencoba menambahkan serangkaian gaya baru ke infrastruktur yang ada, itu akan menyakitkan. Dengan Pabrik Abstrak, yang harus kita lakukan hanyalah membuat pabrik beton baru yang mengimplementasikan kelas pabrik abstrak.

Contohnya adalah counter

• Bagian mobil untuk mobil sport yang digunakan dalam sedan. Ketidakkonsistenan ini dapat menyebabkan kecelakaan.
• Tombol gaya Windows di berbagai widget GUI OS. Itu tidak akan merusak apa pun kecuali melukai pengalaman pengguna bagi sebagian orang, seperti saya.
• Kemudian, kami mengetahui bahwa perangkat lunak kami perlu dijalankan dalam peningkatan OS berikutnya yang memerlukan berbagai objek sistem yang kompatibel sekaligus menjaga perangkat lunak tetap kompatibel.

Oleh karena itu, ketika grup objek akhir harus memiliki gaya yang sama tanpa terkecuali objek dan Anda ingin menyembunyikan detail "menjaga gaya yang sama", maka kita harus menggunakan Pabrik Abstrak.

Sejauh yang saya mengerti arti o Abstrak pabrik dan definisi metode Pabrik yang pertama diimplementasikan dalam konteks statis dan menyediakan objek berdasarkan parameter input.

Yang kedua menggunakan objek yang sudah dibuat (keluarga) yang mengimplementasikan antarmuka metode pabrik. Metode pabrik kemudian membuat contoh spesifik terkait dengan objek asli tidak peduli yang mana itu.

Jadi ini biasanya mengarah ke menggunakan kedua pola bersama di mana pada langkah pertama Anda membuat beberapa objek umum yang menggambarkan keluarga objek terkait. Ini disebut dengan metode static getInstance ("my family name") metode. Implementasi metode getInstance memutuskan objek keluarga mana yang akan dibuat.

Kemudian saya memanggil metode createProduct () pada objek keluarga yang baru dibuat dan bergantung pada objek keluarga, produk baru akan dikembalikan.

Tampaknya pola-pola ini bekerja sama dengan masing-masing.

Dengan kata lain Abstrak Pabrik difokuskan pada "APA" yang akan dibuat dan metode Pabrik "BAGAIMANA" itu akan dibuat.

Yang harus Anda ingat adalah bahwa pabrik abstrak adalah pabrik yang dapat mengembalikan beberapa pabrik . Jadi, jika Anda memiliki AnimalSpeciesFactory, ia dapat mengembalikan pabrik seperti ini:

Mamalfactory, BirdFactory, Fishfactory, ReptileFactory. Sekarang Anda memiliki satu pabrik dari AnimalSpeciesFactory, mereka menggunakan pola pabrik untuk membuat objek tertentu. Misalnya, bayangkan Anda mendapat ReptileFactory dari AnimalFactory ini, maka Anda bisa menawarkan untuk membuat objek reptil seperti: Ular, kura-kura, objek kadal.

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

*/

Pola metode pabrik adalah pola desain kreasi yang berhubungan dengan membuat objek tanpa menunjukkan kelas objek yang dibuat. Pola desain ini pada dasarnya memungkinkan kelas untuk menentang instantiation ke sub-kelas.

Pola Abstrak Pabrik melayani enkapsulasi ke sekelompok pabrik individu tanpa mengekspos kelas beton. Dalam model ini, antarmuka generik dari kelas pabrik abstrak digunakan untuk membuat objek konkret yang diperlukan yang memisahkan detail implementasi objek dari penggunaan dan komposisinya. Pola desain ini banyak digunakan dalam aplikasi GUI di mana komponen GUI yang serupa perlu dibuat.

saat mencari di google saya datang mengikuti blog yang menjelaskan kedua pola desain cemerlang. lihat ini

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

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