Apa perbedaan mendasar antara Pabrik dan Pola Pabrik Abstrak?

Dengan pola Pabrik, Anda menghasilkan contoh implementasi ( Apple, Banana, Cherry, dll) dari interface tertentu - misalnya, IFruit.

Dengan pola Pabrik Abstrak, Anda memberikan cara bagi siapa pun untuk menyediakan pabrik sendiri. Ini memungkinkan gudang Anda menjadi an IFruitFactoryatau IJuiceFactory, tanpa mengharuskan gudang Anda tahu apa-apa tentang buah-buahan atau jus.

Sumber untuk informasi ini diambil dari: http://java.dzone.com/news/intro-design-patterns-abstract

Abstrak Pabrik vs. Metode Pabrik

Metode Pabrik Abstrak diimplementasikan sebagai Metode Pabrik. Pola Pabrik Abstrak dan Pola Metode Pabrik memisahkan sistem klien dari kelas implementasi aktual melalui jenis dan pabrik abstrak. Metode Pabrik menciptakan objek melalui warisan di mana Pabrik Abstrak menciptakan objek melalui komposisi.

Pola Pabrik Abstrak terdiri dari Pabrik Abstrak, Pabrik Beton, Produk Abstrak, Produk Beton, dan Klien.

Bagaimana cara mengimplementasikannya

Pola Pabrik Abstrak dapat diimplementasikan menggunakan Pola Metode Pabrik, Pola Prototipe atau Pola Singleton. Objek ConcreteFactory dapat diimplementasikan sebagai Singleton karena hanya diperlukan satu instance objek ConcreteFactory.

Pola Metode Pabrik adalah versi sederhana dari pola Pabrik Abstrak. Pola Metode Pabrik bertanggung jawab untuk menciptakan produk yang dimiliki oleh satu keluarga, sedangkan pola Pabrik Abstrak berhubungan dengan beberapa keluarga produk.

Metode Pabrik menggunakan antarmuka dan kelas abstrak untuk memisahkan klien dari kelas generator dan produk yang dihasilkan. Abstrak Pabrik memiliki generator yang merupakan wadah untuk beberapa metode pabrik, bersama dengan antarmuka decoupling klien dari generator dan produk.

Kapan Menggunakan Pola Metode Pabrik

Gunakan pola Metode Pabrik saat ada kebutuhan untuk memisahkan klien dari produk tertentu yang digunakannya. Gunakan Metode Pabrik untuk membebaskan klien dari tanggung jawab untuk membuat dan mengonfigurasi contoh produk.

Kapan Menggunakan Pola Pabrik Abstrak

Gunakan pola Pabrik Abstrak saat klien harus dipisahkan dari kelas produk. Terutama berguna untuk konfigurasi dan modifikasi program. Pola Abstrak Pabrik juga dapat menegakkan batasan tentang kelas mana yang harus digunakan dengan yang lain. Mungkin banyak pekerjaan untuk membuat pabrik beton baru.

Contoh:

Pabrik Abstrak Contoh 1

Spesifikasi ini untuk disk untuk menyiapkan berbagai jenis pasta dalam pembuat pasta adalah Pabrik Abstrak, dan masing-masing disk spesifik adalah Pabrik. semua Pabrik (disk pembuat pasta) mewarisi properti mereka dari Pabrik abstrak. Setiap disk berisi informasi tentang cara membuat pasta, dan pembuat pasta tidak.

Pabrik Abstrak Contoh 2:

Peralatan Stamping sesuai dengan Pabrik Abstrak, karena merupakan antarmuka untuk operasi yang membuat objek produk abstrak. Mati sesuai dengan Pabrik Beton, karena mereka menciptakan produk beton. Setiap kategori bagian (Kap, Pintu, dll.) Sesuai dengan produk abstrak. Bagian-bagian tertentu (yaitu, pintu samping pengemudi untuk 99 camry) sesuai dengan produk beton.

Contoh Metode Pabrik:

Perusahaan mainan sesuai dengan Pencipta, karena dapat menggunakan pabrik untuk membuat objek produk. Pembagian perusahaan mainan yang memproduksi jenis mainan tertentu (kuda atau mobil) sesuai dengan ConcreteCreator.

Pola pabrik: Pabrik menghasilkan implementasi produk-IP

Pola Pabrik Abstrak: Sebuah pabrik-pabrik menghasilkan IFactories, yang pada gilirannya menghasilkan IProducts :)

[Perbarui sesuai dengan komentar]
Apa yang saya tulis sebelumnya tidak benar menurut Wikipedia . Pabrik abstrak hanyalah antarmuka pabrik. Dengannya, Anda dapat mengganti pabrik saat runtime, untuk memungkinkan pabrik yang berbeda dalam konteks yang berbeda. Contohnya bisa pabrik yang berbeda untuk OS yang berbeda, penyedia SQL, driver middleware dll.

Pola Pabrik Abstrak

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

• Pola Pabrik Abstrak sangat mirip dengan pola Metode Pabrik. Salah satu perbedaan antara keduanya adalah bahwa dengan pola Abstrak Pabrik, kelas mendelegasikan tanggung jawab instantiasi objek ke objek lain melalui komposisi sedangkan pola Metode Pabrik menggunakan pewarisan dan bergantung pada subkelas untuk menangani instantiasi objek yang diinginkan.

• Sebenarnya, objek yang didelegasikan sering menggunakan metode pabrik untuk melakukan instantiasi!

Pola pabrik

• Pola pabrik adalah contoh pola penciptaan

• Pola penciptaan abstrak proses instantiasi objek. Mereka menyembunyikan bagaimana objek dibuat dan membantu membuat keseluruhan sistem independen dari bagaimana objeknya dibuat dan disusun.

• Pola kreasi kelas fokus pada penggunaan pewarisan untuk memutuskan objek yang akan dipakai Metode Pabrik

• Pola kreasi objek fokus pada pendelegasian instantiation ke objek lain Abstract Factory

Referensi: Pabrik vs Pabrik Abstrak

Metode pabrik: Anda memiliki pabrik yang membuat objek yang berasal dari kelas dasar tertentu

Pabrik abstrak: Anda memiliki pabrik yang membuat pabrik lain , dan pabrik-pabrik ini pada gilirannya menciptakan objek yang berasal dari kelas dasar. Anda melakukan ini karena Anda sering tidak hanya ingin membuat objek tunggal (seperti dengan metode Factory) - alih-alih, Anda ingin membuat koleksi objek terkait.

Abstrak pabrik adalah antarmuka untuk membuat objek terkait tetapi metode pabrik adalah metode. Pabrik abstrak diimplementasikan dengan metode pabrik.

Perbedaan dasar:

Factory: Membuat objek tanpa memaparkan logika instantiation kepada klien.

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

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

AbstractFactory pola menggunakan komposisi untuk mendelegasikan tanggung jawab menciptakan objek ke kelas lain sementara metode Pabrik pola menggunakan warisan dan bergantung pada kelas turunan atau sub kelas untuk membuat objek

Dari artikel oodesign :

Diagram kelas pabrik :

Contoh: StaticFactory

 public class ShapeFactory {

   //use getShape method to get object of type shape 
   public static Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }     
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();

      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();

      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }

      return null;
   }
}

Pabrik Non-Statis yang menerapkan contoh FactoryMethod tersedia di pos ini:

Pola Desain: Metode Pabrik vs Pabrik vs Pabrik Abstrak

Kapan harus menggunakan: Klien hanya perlu kelas dan tidak peduli tentang implementasi konkret yang diperolehnya.

Digaram kelas Metode Pabrik :

Kapan harus digunakan: Klien tidak tahu kelas konkret apa yang harus dibuat saat runtime, tetapi hanya ingin mendapatkan kelas yang akan melakukan pekerjaan.

Abstrak Diagram kelas pabrik dari dzone

Kapan harus digunakan: Ketika sistem Anda harus membuat banyak keluarga produk atau Anda ingin menyediakan perpustakaan produk tanpa memaparkan rincian implementasi.

Contoh kode sumber dalam artikel di atas sangat baik untuk memahami konsep dengan jelas.

Pertanyaan SE terkait dengan contoh kode:

Pola Pabrik. Kapan harus menggunakan metode pabrik?

Perbedaan:

1. Abstrak Kelas pabrik sering diimplementasikan dengan Metode Pabrik, tetapi mereka juga dapat diimplementasikan menggunakan Prototipe
2. Desain mulai menggunakan Metode Pabrik (kurang rumit, lebih dapat dikustomisasi, subkelas berkembang biak) dan berkembang menuju pola kreasi lainnya (lebih fleksibel, lebih kompleks) di mana lebih banyak fleksibilitas diperlukan.
3. Metode Pabrik biasanya disebut dalam Metode Templat.

Artikel bermanfaat lainnya:

factory_method dari pembuatan sumber

abstract_factory dari pembuatan sumber

abstrak-pabrik-desain-pola dari journaldev

Contoh / Skenario untuk Pabrik Abstrak

Saya tinggal di tempat di mana hujan turun di musim hujan, salju di musim dingin dan panas dan cerah di musim panas. Saya membutuhkan berbagai jenis pakaian untuk melindungi diri saya dari elemen-elemen ini. Untuk melakukannya saya pergi ke toko di dekat rumah saya dan meminta pakaian / barang untuk melindungi diri. Penjaga toko memberi saya barang yang tepat sesuai lingkungan dan kedalaman saku saya. Item yang dia berikan kepada saya memiliki tingkat kualitas dan kisaran harga yang sama. Karena dia menyadari standar saya, mudah baginya untuk melakukannya. Tetapi ketika seorang pria kaya dari seberang jalan muncul dengan persyaratan yang sama, ia mendapatkan barang bermerek yang mahal. Satu hal yang nyata adalah semua barang yang dia berikan kepada saya saling melengkapi dalam hal kualitas, standar, dan biaya. Orang bisa mengatakan mereka pergi bersama. Sama halnya dengan item yang didapat orang kaya ini.

Jadi dengan melihat skenario di atas, saya sekarang menghargai efisiensi penjaga toko. Saya dapat mengganti pemilik toko ini dengan Toko Abstrak. Item yang kami dapatkan dengan item abstrak dan saya dan orang kaya sebagai klien perspektif. Yang kita butuhkan adalah produk / barang yang sesuai dengan kebutuhan kita.

Sekarang saya dapat dengan mudah melihat diri saya mempertimbangkan toko online yang menyediakan serangkaian layanan kepada banyak kliennya. Setiap klien termasuk dalam salah satu dari tiga kelompok. Ketika pengguna grup premium membuka situs yang mendapat UI luar biasa, panel iklan yang sangat disesuaikan, lebih banyak opsi dalam menu, dll. Serangkaian fitur yang sama ini disajikan kepada pengguna emas tetapi fungsionalitas dalam menu lebih sedikit, sebagian besar iklan dilepaskan, dan UI yang sedikit kurang ekonomis. Terakhir adalah jenis pengguna saya, pengguna 'grup gratis'. Saya cukup dilayani sehingga saya tidak tersinggung. UI adalah minimum, iklan jauh dari jalur sehingga saya tidak tahu apa yang ada di dalamnya, terakhir menu hanya logout.

Jika saya mendapatkan kesempatan untuk membangun sesuatu seperti situs web ini, saya pasti akan mempertimbangkan Pola Pabrik Abstrak.

Produk Abstrak: Panel Iklan, Menu, pelukis UI.
Pabrik Abstrak: Pengalaman Pengguna Web Store
Pabrik Concreate: Pengalaman Pengguna Premium, Pengalaman Pengguna Emas, Pengalaman Pengguna Umum.

Mungkin banyak orang akan terkejut, tetapi pertanyaan ini salah . Jika Anda mendengar pertanyaan ini selama wawancara, Anda perlu membantu pewawancara memahami di mana kebingungan itu.

Mari kita mulai dari kenyataan bahwa tidak ada pola konkret yang disebut hanya "Pabrik". Ada pola yang disebut "Pabrik Abstrak", dan ada pola yang disebut "Metode Pabrik".

Jadi, apa artinya "Pabrik"? salah satu dari yang berikut (semua dapat dianggap benar, tergantung pada ruang lingkup referensi):

• Beberapa orang menggunakannya sebagai alias (pintasan) untuk " Pabrik Abstrak ".
• Beberapa orang menggunakannya sebagai alias (pintasan) untuk " Metode Pabrik ".
• Beberapa orang menggunakannya sebagai nama yang lebih umum untuk semua pola pabrik / kreasi. Misalnya "Pabrik Abstrak" dan "Metode Pabrik" adalah Pabrik.

Dan, sayangnya , banyak orang menggunakan "Pabrik" untuk menunjukkan jenis pabrik lain, yang menciptakan pabrik atau pabrik (atau antarmuka mereka). Berdasarkan teori mereka:

Produk mengimplementasikan IProduct, yang dibuat oleh Factory, yang mengimplementasikan IFactory, yang dibuat oleh AbstractFactory.

Untuk memahami betapa konyolnya hal ini, mari kita lanjutkan persamaan kami:

AbstractFactory mengimplementasikan IAbstractFactory, yang dibuat oleh ... AbstractAbstractFactory ???

Saya harap Anda mengerti intinya. Jangan bingung, dan tolong jangan menciptakan hal-hal yang tidak ada karena alasan.

-

PS : Pabrik untuk Produk adalah AbstractFactory, dan Factory for Abstract Factory akan menjadi contoh lain dari AbstractFactory juga.

//Abstract factory - Provides interface to create factory of related products
interface PizzaIngredientsFactory{    
   public Dough createDough(); //Will return you family of Dough
   public Clam createClam();   //Will return you family of Clam
   public Sauce createSauce(); //Will return you family of Sauce
}

class NYPizzaIngredientsFactory implements PizzaIngredientsFactory{

   @Override
   public Dough createDough(){
      //create the concrete dough instance that NY uses
      return doughInstance;
   }

   //override other methods
} 

Definisi buku teks sudah disediakan oleh jawaban lain. Saya pikir saya akan memberikan contohnya juga.

Jadi di sini PizzaIngredientsFactoryadalah pabrik abstrak karena menyediakan metode untuk menciptakan keluarga produk terkait.

Perhatikan bahwa setiap metode di pabrik Abstrak adalah metode Pabrik itu sendiri. Seperti createDough()itu sendiri merupakan metode pabrik yang implementasi konkretnya akan disediakan oleh subclass seperti NYPizzaIngredientsFactory. Jadi menggunakan ini setiap lokasi yang berbeda dapat membuat contoh bahan beton milik lokasi mereka.

Metode Pabrik

Memberikan contoh implementasi konkret

Dalam contoh:
- createDough()- memberikan implementasi konkret untuk adonan. Jadi ini adalah metode pabrik

Pabrik Abstrak

Menyediakan antarmuka untuk membuat kumpulan objek terkait

Dalam contoh:
- PizzaIngredientsFactoryadalah pabrik abstrak karena memungkinkan untuk membuat satu set terkait benda seperti Dough, Clams, Sauce. Untuk membuat setiap kumpulan benda, ia menyediakan metode pabrik.

Contoh dari Head First pola desain

Saya memiliki beberapa poin untuk disumbangkan dengan jawaban John sebagai berikut:

Pabrik abstrak adalah pabrik pabrik!

Dengan "Metode Pabrik" (karena hanya "Pabrik" yang ambigu), Anda menghasilkan implementasi (Lemon , Orange, dll) dari interface tertentu - misalnya, IFruit. Pabrik ini bisa disebut CitricFruitFactory.

Tapi sekarang Anda ingin membuat jenis buah lain yang tidak bisa dibuat oleh CitricFruitFactory. Mungkin kode CitricFruitFactorytidak masuk akal jika Anda membuatnya Strawberrydi dalamnya (stroberi bukan buah sitrat!).

Jadi Anda bisa membuat Pabrik baru yang disebut RedFruitFactoryyang menghasilkan Strawberry,Raspberry dll

Seperti yang dikatakan John Feminella: "Dengan pola Abstrak Pabrik, Anda menghasilkan implementasi antarmuka Pabrik tertentu - misalnya,IFruitFactory ,. Masing-masing dari mereka tahu cara membuat berbagai jenis buah."

Implementasi itu IFruitFactoryadalah CitricFruitFactorydan RedFruitFactory!

Sumber saya adalah: StackOverflow, tutorialspoint.com, programmers.stackexchange.comdan CodeProject.com.

Factory Method(Disebut juga Factory) untuk klien yang terpisah dari suatu Interfaceimplementasi. Sebagai contoh, kami memiliki Shapeantarmuka dengan dua Circledan Squareimplementasi. Kami telah mendefinisikan kelas pabrik dengan metode pabrik dengan parameter penentu seperti Typedan implementasi Shapeantarmuka terkait yang baru .

Abstract Factoryberisi beberapa metode pabrik atau antarmuka pabrik oleh beberapa implementasi pabrik. Untuk contoh di atas selanjutnya kami memiliki Colorantarmuka dengan dua Reddan Yellowimplementasi. Kami telah mendefinisikan ShapeColorFactoryantarmuka dengan dua RedCircleFactorydan YellowSquareFactory. Kode berikut untuk menjelaskan konsep ini:

interface ShapeColorFactory
{
    public Shape getShape();
    public Color getColor();
}

class RedCircleFactory implements ShapeColorFactory
{
    @Override
    public Shape getShape() {
        return new Circle();
    }

    @Override
    public Color getColor() {
        return new Red();
    }
}
class YellowSquareFactory implements ShapeColorFactory
{
    @Override
    public Shape getShape() {
        return new Square();
    }

    @Override
    public Color getColor() {
        return new Yellow();
    }
} 

Di sini perbedaan antara FactoryMethoddan AbstractFactory. Factory Methodhanya mengembalikan kelas konkret antarmuka tetapi Abstract Factorykembali factory of factory. Dengan kata lain Abstract Factorymengembalikan kombinasi yang berbeda dari serangkaian antarmuka.

Semoga penjelasan saya bermanfaat.

Perbedaan utama dalam pabrik-pabrik itu adalah ketika apa yang ingin Anda lakukan dengan pabrik-pabrik itu dan kapan Anda ingin menggunakannya.

Terkadang, ketika Anda melakukan IOC (inversi kontrol mis. Injeksi konstruktor), Anda tahu bahwa Anda bisa membuat benda padat. Seperti disebutkan dalam contoh buah di atas, jika Anda siap membuat objek buah, Anda dapat menggunakan pola pabrik sederhana .

Tetapi berkali-kali, Anda tidak ingin membuat benda padat, mereka akan datang nanti dalam aliran program. Tetapi konfigurasi memberi tahu Anda apa jenis pabrik yang ingin Anda gunakan di awal, alih-alih membuat objek, Anda bisa meneruskan pabrik yang diturunkan dari kelas pabrik umum ke konstruktor di IOC.

Jadi, saya pikir itu juga tentang objek seumur hidup dan penciptaan.

Keduanya Factory Methoddan Abstract Factorymenjaga klien dipisahkan dari jenis beton. Keduanya membuat objek, tetapi Factorymetode menggunakan pewarisan sedangkanAbstract Factory menggunakan komposisi.

The Factory Methoddiwariskan dalam subclass untuk membuat benda-benda konkret (produk) sedangkanAbstract Factory menyediakan antarmuka untuk menciptakan keluarga produk-produk terkait dan subclass dari antarmuka ini menentukan bagaimana menciptakan produk-produk terkait.

Kemudian subclass ini ketika dipakai dipakai ke dalam kelas produk di mana ia digunakan sebagai tipe abstrak. Produk-produk terkait dalam suatu Abstract Factorysering diimplementasikan menggunakan Factory Method.

Memperluas jawaban John Feminella:

Apple, Banana, CherryAlat FruitFactorydan yang memiliki metode yang disebut Createyang bertanggung jawab sepenuhnya menciptakan Apple atau Pisang atau Cherry. Anda selesai, dengan Factorymetode Anda .

Sekarang, Anda ingin Createsalad khusus dari buah-buahan Anda dan ada Pabrik Abstrak Anda . Abstrak Factory tahu cara membuat Salad khusus Anda dari Apple, Banana, dan Cherry.

public class Apple implements Fruit, FruitFactory {
    public Fruit Create() {
        // Apple creation logic goes here
    }
}

public class Banana implements Fruit, FruitFactory {
    public Fruit Create() {
        // Banana creation logic goes here
    }
}

public class Cherry implements Fruit, FruitFactory {
    public Fruit Create() {
        // Cherry creation logic goes here
    }
}

public class SpecialSalad implements Salad, SaladFactory {
    public static Salad Create(FruitFactory[] fruits) {
        // loop through the factory and create the fruits.
        // then you're ready to cut and slice your fruits 
        // to create your special salad.
    }
}

Menurut Definisi kita dapat menyeret perbedaan dua:

Pabrik: Antarmuka digunakan untuk membuat objek, tetapi subkelas memutuskan kelas mana yang akan dipakai. Penciptaan objek dilakukan ketika diperlukan.

Abstrak Pabrik: Pola pabrik abstrak bertindak sebagai pabrik super yang menciptakan pabrik lain. Dalam pola abstrak Factory, antarmuka bertanggung jawab untuk membuat satu set objek terkait, atau objek dependen tanpa menentukan kelas konkretnya.

Jadi, dalam definisi di atas kita dapat menekankan pada perbedaan tertentu. yaitu, pola Pabrik bertanggung jawab untuk membuat objek dan Pabrik Abstrak bertanggung jawab untuk membuat satu set objek terkait; jelas keduanya melalui antarmuka.

Pola pabrik:

public interface IFactory{
  void VehicleType(string n);
 }

 public class Scooter : IFactory{
  public void VehicleType(string n){
   Console.WriteLine("Vehicle type: " + n);
  }
 }

 public class Bike : IFactory{
  public void VehicleType(string n) {
  Console.WriteLine("Vehicle type: " + n);
  }
 }

 public interface IVehicleFactory{
  IFactory GetVehicleType(string Vehicle);
 }

 public class ConcreteVehicleFactory : IVehicleFactory{
 public IFactory GetVehicleType(string Vehicle){
   switch (Vehicle){
    case "Scooter":
     return new Scooter();
    case "Bike":
     return new Bike();
    default:
    return new Scooter();
  }
 }

 class Program{
  static void Main(string[] args){
   IVehicleFactory factory = new ConcreteVehicleFactory();
   IFactory scooter = factory.GetVehicleType("Scooter");
   scooter.VehicleType("Scooter");

   IFactory bike = factory.GetVehicleType("Bike");
   bike.VehicleType("Bike");

   Console.ReadKey();
 }
}

Pola Pabrik Abstrak:

interface IVehicleFactory{
 IBike GetBike();
 IScooter GetScooter();
}

class HondaFactory : IVehicleFactory{
     public IBike GetBike(){
            return new FZS();
     }
     public IScooter GetScooter(){
            return new FZscooter();
     }
 }
class HeroFactory: IVehicleFactory{
      public IBike GetBike(){
            return new Pulsur();
     }
      public IScooter GetScooter(){
            return new PulsurScooter();
     }
}

interface IBike
    {
        string Name();
    }
interface IScooter
    {
        string Name();
    }

class FZS:IBike{
   public string Name(){
     return "FZS";
   }
}
class Pulsur:IBike{
   public string Name(){
     return "Pulsur";
   }
}

class FZscooter:IScooter {
  public string Name(){
     return "FZscooter";
   }
}

class PulsurScooter:IScooter{
  public string Name(){
     return "PulsurScooter";
   }
}

enum MANUFACTURERS
{
    HONDA,
    HERO
}

class VehicleTypeCheck{
        IBike bike;
        IScooter scooter;
        IVehicleFactory factory;
        MANUFACTURERS manu;

        public VehicleTypeCheck(MANUFACTURERS m){
            manu = m;
        }

        public void CheckProducts()
        {
            switch (manu){
                case MANUFACTURERS.HONDA:
                    factory = new HondaFactory();
                    break;
                case MANUFACTURERS.HERO:
                    factory = new HeroFactory();
                    break;
            }

      Console.WriteLine("Bike: " + factory.GetBike().Name() + "\nScooter: " +      factory.GetScooter().Name());
        }
  }

class Program
    {
        static void Main(string[] args)
        {
            VehicleTypeCheck chk = new VehicleTypeCheck(MANUFACTURERS.HONDA);
            chk.CheckProducts();

            chk= new VehicleTypeCheck(MANUFACTURERS.HERO);
            chk.CheckProducts();

            Console.Read();
        }
    }

Periksa di sini: http://www.allapplabs.com/java_design_patterns/abstract_factory_pattern.htm tampaknya metode Pabrik menggunakan kelas tertentu (bukan abstrak) sebagai kelas dasar sementara pabrik Abstrak menggunakan kelas abstrak untuk ini. Juga jika menggunakan antarmuka bukan kelas abstrak hasilnya akan menjadi implementasi yang berbeda dari pola Pabrik Abstrak.

: D

Abstract Factory adalah template untuk membuat berbagai jenis antarmuka. Misalkan Anda memiliki proyek yang mengharuskan Anda mem-parsing berbagai jenis file csv yang berisi informasi kuantitas, harga, dan item tertentu seperti beberapa berisi data tentang buah-buahan selain coklat dan kemudian setelah penguraian, Anda perlu memperbarui informasi ini dalam database terkait sehingga sekarang Anda dapat memiliki satu pabrik abstrak mengembalikan Anda pabrik parser dan pengubah dan kemudian pabrik parser ini dapat mengembalikan Anda objek parser Chocolate, Fruit Parser Object dll. dan juga Pabrik Pengubah dapat mengembalikan objek pengubah Chocolate, objek Pengubah Buah dll.

Saya pikir kita dapat memahami perbedaan antara keduanya dengan melihat kode contoh Java8:

  interface Something{}

  interface OneWhoCanProvideSomething {
     Something getSomething();
  }

  interface OneWhoCanProvideCreatorsOfSomething{
     OneWhoCanProvideSomething getCreator();
  }


public class AbstractFactoryExample {

    public static void main(String[] args) {
        //I need something
        //Let's create one
        Something something = new Something() {};

        //Or ask someone (FACTORY pattern)
        OneWhoCanProvideSomething oneWhoCanProvideSomethingOfTypeA = () -> null;
        OneWhoCanProvideSomething oneWhoCanProvideSomethingOfTypeB = () -> null;

        //Or ask someone who knows soemone who can create something (ABSTRACT FACTORY pattern)
        OneWhoCanProvideCreatorsOfSomething oneWhoCanProvideCreatorsOfSomething = () -> null;

        //Same thing, but you don't need to write you own interfaces
        Supplier<Something> supplierOfSomething = () -> null;
        Supplier<Supplier<Something>> supplierOfSupplier = () -> null;
    }

}

Sekarang pertanyaannya adalah cara penciptaan mana yang harus Anda gunakan dan mengapa: Cara pertama (tanpa pola, hanya konstruktor sederhana): membuat sendiri bukanlah ide yang baik, Anda harus melakukan semua pekerjaan, dan kode klien Anda terikat pada implementasi tertentu.

Cara kedua (menggunakan pola Pabrik): memberi Anda manfaat bahwa Anda dapat melewati semua jenis implementasi, yang dapat memberikan berbagai jenis sesuatu berdasarkan pada beberapa kondisi (mungkin parameter diteruskan ke metode pembuatan).

Cara ketiga (menggunakan pola Pabrik Abstrak): Ini memberi Anda lebih banyak fleksibilitas. Anda dapat menemukan berbagai jenis pembuat sesuatu berdasarkan pada beberapa kondisi (mungkin parameter dilewati).

Perhatikan bahwa Anda selalu bisa lolos dengan pola Pabrik dengan menggabungkan dua kondisi bersama-sama (yang sedikit meningkatkan kompleksitas kode, dan pemasangan), saya kira itu sebabnya kita jarang melihat kasus penggunaan nyata pola Pabrik Abstrak.