Apa perbedaan antara pola desain Builder dan pola desain Factory?

Mana yang lebih menguntungkan dan mengapa?

Bagaimana cara merepresentasikan temuan saya sebagai grafik jika saya ingin menguji dan membandingkan / membandingkan pola-pola ini?

Dengan pola desain, biasanya tidak ada solusi "lebih menguntungkan" yang berfungsi untuk semua kasus. Itu tergantung pada apa yang Anda perlu implementasikan.

Dari Wikipedia:

• Builder berfokus pada membangun objek yang kompleks selangkah demi selangkah. Abstrak Pabrik menekankan keluarga objek produk (baik yang sederhana maupun kompleks). Builder mengembalikan produk sebagai langkah terakhir, tetapi sejauh menyangkut Pabrik Abstrak, produk akan segera dikembalikan.
• Builder sering membuat Composite.
• Seringkali, desain mulai menggunakan Metode Pabrik (kurang rumit, lebih dapat disesuaikan, subkelas berkembang biak) dan berkembang menuju Pabrik Abstrak, Prototipe, atau Builder (lebih fleksibel, lebih kompleks) ketika perancang menemukan di mana lebih banyak fleksibilitas diperlukan.
• Terkadang pola kreasi saling melengkapi: Builder dapat menggunakan salah satu pola lain untuk menerapkan komponen mana yang dibangun. Abstrak Factory, Builder, dan Prototype dapat menggunakan Singleton dalam implementasinya.

Entri Wikipedia untuk pola desain pabrik: http://en.wikipedia.org/wiki/Factory_method_pattern

Entri Wikipedia untuk pola desain pembangun: http://en.wikipedia.org/wiki/Builder_pattern

Sebuah pabrik hanyalah fungsi pembungkus di sekitar konstruktor (mungkin satu di kelas yang berbeda). Perbedaan utama adalah bahwa pola metode pabrik membutuhkan seluruh objek yang akan dibangun dalam pemanggilan metode tunggal, dengan semua parameter diteruskan pada satu baris. Objek terakhir akan dikembalikan.

Pola pembangun , di sisi lain, pada dasarnya adalah objek pembungkus di sekitar semua parameter yang mungkin Anda inginkan untuk dilewatkan ke permohonan konstruktor. Ini memungkinkan Anda menggunakan metode penyetel untuk secara perlahan membangun daftar parameter Anda. Satu metode tambahan pada kelas builder adalah metode build (), yang hanya meneruskan objek builder ke konstruktor yang diinginkan, dan mengembalikan hasilnya.

Dalam bahasa statis seperti Java, ini menjadi lebih penting ketika Anda memiliki lebih dari beberapa parameter (berpotensi opsional), karena menghindari persyaratan untuk memiliki konstruktor teleskopik untuk semua kemungkinan kombinasi parameter. Builder juga memungkinkan Anda menggunakan metode setter untuk mendefinisikan bidang read-only atau privat yang tidak dapat langsung dimodifikasi setelah konstruktor dipanggil.

Contoh Pabrik Dasar

// Factory
static class FruitFactory {
    static Fruit create(name, color, firmness) {
        // Additional logic
        return new Fruit(name, color, firmness);
    }
}

// Usage
Fruit fruit = FruitFactory.create("apple", "red", "crunchy");

Contoh Pembangun Dasar

// Builder
class FruitBuilder {
    String name, color, firmness;
    FruitBuilder setName(name)         { this.name     = name;     return this; }
    FruitBuilder setColor(color)       { this.color    = color;    return this; }
    FruitBuilder setFirmness(firmness) { this.firmness = firmness; return this; }
    Fruit build() {
        return new Fruit(this); // Pass in the builder
    }
}

// Usage
Fruit fruit = new FruitBuilder()
        .setName("apple")
        .setColor("red")
        .setFirmness("crunchy")
        .build();

Mungkin layak membandingkan sampel kode dari dua halaman wikipedia ini:

http://en.wikipedia.org/wiki/Factory_method_pattern
http://en.wikipedia.org/wiki/Builder_pattern

Pola Pabrik hampir dapat dilihat sebagai versi sederhana dari pola Builder.

Dalam pola Pabrik , pabrik bertugas menciptakan berbagai subtipe objek tergantung pada kebutuhan.

Pengguna metode pabrik tidak perlu tahu subtipe yang tepat dari objek itu. Contoh metode pabrik createCarmungkin mengembalikan objek yang diketik Fordatau Honda.

Dalam pola Builder , subtipe berbeda juga dibuat oleh metode builder, tetapi komposisi objek mungkin berbeda dalam subkelas yang sama.

Untuk melanjutkan contoh mobil Anda mungkin memiliki createCarmetode pembangun yang membuat Hondaobjek -typed dengan mesin 4 silinder, atau Hondaobjek -typed dengan 6 silinder. Pola pembangun memungkinkan granularitas yang lebih halus ini.

Diagram dari kedua pola Builder dan pola metode Factory tersedia di Wikipedia.

Pola desain pembangun menggambarkan objek yang tahu cara membuat objek lain dari jenis tertentu melalui beberapa langkah. Itu memegang keadaan yang dibutuhkan untuk item target pada setiap langkah menengah. Pikirkan apa yang StringBuilder lewati untuk menghasilkan string terakhir.

Pola desain pabrik menggambarkan objek yang tahu cara membuat beberapa jenis objek yang berbeda namun terkait dalam satu langkah, di mana jenis spesifik dipilih berdasarkan parameter yang diberikan. Pikirkan sistem serialisasi, tempat Anda membuat serializer dan membangun objek yang diinginkan semuanya dalam satu panggilan panggilan.

• Membangun objek langkah demi langkah yang kompleks: pola pembangun

• Objek sederhana dibuat dengan menggunakan metode tunggal: pola metode pabrik

• Membuat Obyek dengan menggunakan beberapa metode pabrik: Pola pabrik abstrak

Pola Pembuat dan Pola Pabrik, keduanya tampak sangat mirip dengan mata telanjang karena keduanya menciptakan objek untuk Anda.

Tetapi Anda perlu melihat lebih dekat

Contoh kehidupan nyata ini akan membuat perbedaan antara keduanya menjadi lebih jelas.

Misalkan, Anda pergi ke restoran cepat saji dan Anda memesan makanan .

1) Makanan Apa?

Pizza

2) Topping apa?

Capsicum, Tomat, BBQ chicken, TANPA NANAS

Jadi berbagai jenis makanan dibuat oleh pola Pabrik tetapi varian (rasa) yang berbeda dari makanan tertentu dibuat oleh pola Builder.

Berbagai jenis makanan

Pizza, Burger, Pasta

Varian Pizza

Hanya Keju, Keju + Tomat + Capsicum, Keju + Tomat, dll.

Contoh kode

Anda dapat melihat penerapan kode sampel dari kedua pola di sini
Pola Builder Pattern
Factory Pattern

Keduanya adalah pola Penciptaan, untuk membuat Obyek.

1) Pola Pabrik - Asumsikan, Anda memiliki satu kelas super dan N jumlah sub kelas. Objek yang dibuat tergantung pada parameter / nilai yang dilewatkan.

2) Pola pembangun - untuk membuat objek yang kompleks.

Ex: Make a Loan Object. Loan could be house loan, car loan ,
    education loan ..etc. Each loan will have different interest rate, amount ,  
    duration ...etc. Finally a complex object created through step by step process.

Pertama, beberapa hal umum untuk mengikuti argumentasi saya:

Tantangan utama dalam merancang sistem perangkat lunak besar adalah bahwa mereka harus fleksibel dan tidak rumit untuk berubah. Untuk alasan ini, ada beberapa metrik seperti kopling dan kohesi. Untuk mencapai sistem yang dapat dengan mudah diubah atau diperluas fungsinya tanpa perlu mendesain ulang seluruh sistem dari awal, Anda dapat mengikuti prinsip-prinsip desain (seperti SOLID, dll.). Setelah beberapa saat pengembang mengakui bahwa jika mereka mengikuti prinsip-prinsip itu ada beberapa solusi serupa yang bekerja dengan baik untuk masalah serupa. Solusi standar itu ternyata adalah pola desain.

Jadi pola desain adalah untuk mendukung Anda untuk mengikuti prinsip-prinsip desain umum untuk mencapai sistem yang digabungkan secara longgar dengan kohesi yang tinggi.

Menjawab pertanyaan:

Dengan menanyakan perbedaan antara dua pola, Anda harus bertanya pada diri sendiri pola apa yang membuat sistem Anda lebih fleksibel. Setiap pola memiliki tujuannya sendiri untuk mengatur dependensi antar kelas di sistem Anda.

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

Apa artinya ini: Dengan menyediakan antarmuka seperti ini panggilan ke konstruktor dari masing-masing produk keluarga dirangkum dalam kelas pabrik. Dan karena ini adalah satu-satunya tempat di seluruh sistem Anda di mana konstruktor dipanggil Anda dapat mengubah sistem Anda dengan menerapkan kelas pabrik baru. Jika Anda menukar representasi pabrik melalui pabrik lain, Anda dapat menukar seluruh rangkaian produk tanpa menyentuh mayoritas kode Anda.

Pola Pembangun: GoF: "Pisahkan konstruksi objek yang kompleks dari perwakilannya sehingga proses konstruksi yang sama dapat membuat representasi yang berbeda."

Apa artinya ini: Anda merangkum proses konstruksi di kelas lain, yang disebut direktur (GoF). Direktur ini berisi algoritme untuk membuat instance baru produk (misalnya, menyusun produk kompleks dari bagian lain). Untuk membuat bagian integral dari keseluruhan produk, direktur menggunakan pembangun. Dengan menukar pembuat dalam direktur Anda dapat menggunakan algoritma yang sama untuk membuat produk, tetapi mengubah representasi bagian tunggal (dan juga representasi produk). Untuk memperluas atau memodifikasi sistem Anda dalam representasi produk, yang perlu Anda lakukan adalah menerapkan kelas pembangun baru.

Singkatnya: Tujuan Pola Pabrik Abstrak adalah untuk menukar serangkaian produk yang dibuat untuk digunakan bersama. Tujuan Pola Pembuat adalah untuk merangkum algoritma abstrak untuk menciptakan suatu produk untuk digunakan kembali untuk berbagai representasi produk.

Menurut pendapat saya, Anda tidak bisa mengatakan bahwa Pola Pabrik Abstrak adalah kakak dari Pola Pembangun. YA, keduanya adalah pola penciptaan, tetapi tujuan utama dari pola-pola itu sama sekali berbeda.

Satu perbedaan mencolok antara Builder & pabrik yang bisa saya lihat adalah sebagai berikut

misalkan kita punya mobil

class Car
{
  bool HasGPS;
  bool IsCityCar;
  bool IsSportsCar;
  int   Cylenders;
  int Seats;

  public:
     void Car(bool hasGPs=false,bool IsCityCar=false,bool IsSportsCar=false, int Cylender=2, int Seats=4);
 };

Di antarmuka di atas kita bisa mendapatkan mobil dengan cara berikut:

 int main()
 {
    BadCar = new Car(false,false,true,4,4);
  }

tetapi bagaimana jika, beberapa pengecualian terjadi saat membuat Kursi ??? ANDA TIDAK AKAN MENDAPATKAN OBYEK SAMA SEKALI // TETAPI

misalkan Anda memiliki implementasi seperti berikut ini

class Car
 {
    bool mHasGPS;
    bool mIsCityCar;
    bool mIsSportsCar;
    int mCylenders;
    int mSeats;

 public:
    void Car() : mHasGPs(false), mIsCityCar(false), mIsSportsCar(false), mCylender(2), mSeats(4) {}
    void SetGPS(bool hasGPs=false)  {mHasGPs = hasGPs;}
    void SetCity(bool CityCar)  {mIsCityCar = CityCar;}
    void SetSports(bool SportsCar)  {mIsSportsCar = SportsCar;}
    void SetCylender(int Cylender)  {mCylenders = Cylender;}    
    void SetSeats(int seat) {mSeats = seat;}    
};

 class CarBuilder 
 {
    Car* mCar;
public:
        CarBuilder():mCar(NULL) {   mCar* = new Car();  }
        ~CarBuilder()   {   if(mCar)    {   delete mCar;    }
        Car* GetCar()   {   return mCar; mCar=new Car();    }
        CarBuilder* SetSeats(int n) {   mCar->SetSeats(n); return this; }
        CarBuilder* SetCylender(int n)  {   mCar->SetCylender(n); return this;  }
        CarBuilder* SetSports(bool val) {   mCar->SetSports(val); return this;  }
        CarBuilder* SetCity(bool val)   {   mCar->SetCity(val); return this;    }
        CarBuilder* SetGPS(bool val)    {   mCar->SetGPS(val); return this; }
}

Sekarang Anda bisa membuatnya seperti ini

 int main()
 {
   CarBuilder* bp =new CarBuilder;
    Car* NewCar  = bp->SetSeats(4)->SetSports(4)->SetCity(ture)->SetGPS(false)->SetSports(true)->GetCar();

     bp->SetSeats(2);

     bp->SetSports(4);

     bp->SetCity(ture);

     bp->SetSports(true)

     Car* Car_II=  bp->GetCar();

  }

Di sini, dalam kasus kedua, bahkan jika satu operasi gagal Anda masih akan mendapatkan Mobil.

Mungkin mobil itu tidak berfungsi dengan baik nanti, tetapi Anda akan memiliki objek.

Karena Metode Pabrik memberi Anda Mobil dalam satu panggilan, sedangkan Builder membangun satu per satu.

Meskipun, itu tergantung pada kebutuhan berkenaan mana yang harus pergi.

+-------------------------------------------------------------------+---------------------------------------------------+
|                              Builder                              |                      Factory                      |
+-------------------------------------------------------------------+---------------------------------------------------+
| Return only single instance to handle complex object construction | Retrun various instances on multiple constructors |
| No interface required                                             | Interface driven                                  |
| Inner classes is involved (to avoid telescopic constructors)      | Subclasses are involved                           |
+-------------------------------------------------------------------+---------------------------------------------------+  

Pola Konstruktor Telescoping

Analogi:

• Pabrik: Pertimbangkan restoran. Penciptaan "makanan hari ini" adalah pola pabrik, karena Anda memberi tahu dapur "ambilkan saya makanan hari ini" dan dapur (pabrik) memutuskan objek apa yang akan dihasilkan, berdasarkan kriteria tersembunyi.
• Builder: Builder muncul jika Anda memesan pizza khusus. Dalam hal ini, pelayan memberi tahu koki (pembangun), "Saya butuh pizza; tambahkan keju, bawang, dan daging asap!" Dengan demikian, pembangun memperlihatkan atribut yang seharusnya dimiliki objek, tetapi menyembunyikan cara mengaturnya.

Kesopanan

Pabrik Builder dan Abstrak dimaksudkan untuk tujuan yang berbeda. Tergantung pada kasus penggunaan yang tepat, Anda harus memilih pola desain yang sesuai.

Fitur menonjol Builder :

1. Pola pembangun membangun objek yang kompleks menggunakan objek sederhana dan menggunakan pendekatan langkah demi langkah
2. Kelas Builder membangun objek akhir langkah demi langkah. Pembangun ini tidak tergantung pada objek lain
3. Metode Penggantian ke Pabrik / Pabrik Abstrak dalam skenario ini: Terlalu banyak argumen untuk diteruskan dari program klien ke kelas Pabrik yang bisa rentan kesalahan
4. Beberapa parameter mungkin opsional seperti di Pabrik yang memaksa untuk mengirim semua parameter

Pabrik ( Pabrik sederhana) fitur yang menonjol:

1. Pola penciptaan
2. Berdasarkan warisan
3. Factory mengembalikan Factory Method (antarmuka) yang pada gilirannya mengembalikan Objek Beton
4. Anda dapat mengganti objek beton baru untuk antarmuka dan klien (penelepon) tidak harus menyadari semua implementasi nyata
5. Klien selalu mengakses antarmuka saja dan Anda dapat menyembunyikan detail pembuatan objek dalam metode Pabrik.

Seringkali, desain mulai menggunakan Metode Pabrik (kurang rumit, lebih dapat disesuaikan, subkelas berkembang biak) dan berkembang menuju Pabrik Abstrak , Prototipe , atau Builder (lebih fleksibel, lebih kompleks)

Lihat posting terkait:

Menjaga pembangun di kelas terpisah (antarmuka lancar)

Pola Desain: Metode Pabrik vs Pabrik vs Pabrik Abstrak

Anda dapat merujuk ke artikel di bawah ini untuk lebih jelasnya:

pembuatan sumber daya

journaldev

Pabrik : Digunakan untuk membuat instance objek di mana dependensi objek sepenuhnya dipegang oleh pabrik. Untuk pola pabrik abstrak , seringkali ada banyak implementasi konkret dari pabrik abstrak yang sama. Implementasi yang tepat dari pabrik disuntikkan melalui injeksi ketergantungan.

Builder : Digunakan untuk membangun objek yang tidak dapat diubah , ketika dependensi objek yang akan dipakai sebagian diketahui sebelumnya dan sebagian disediakan oleh klien pembangun.

Abstrak Factory & Builder pattern keduanya adalah pola Creational tetapi dengan maksud berbeda.

Abstrak Factory Pattern menekankan pembuatan objek untuk keluarga objek terkait di mana:

• Setiap keluarga adalah seperangkat kelas yang berasal dari kelas dasar / Antarmuka umum.
• Setiap objek dikembalikan segera sebagai hasil dari satu panggilan.

Pola pembangun berfokus pada membangun objek yang kompleks selangkah demi selangkah. Ini memisahkan representasi dari proses membangun objek yang kompleks, sehingga proses konstruksi yang sama dapat digunakan untuk representasi yang berbeda.

• Objek pembangun merangkum konfigurasi objek yang kompleks.
• Objek sutradara mengetahui protokol menggunakan Builder, di mana protokol mendefinisikan semua langkah logis yang diperlukan untuk membangun objek yang kompleks.

Konstruksi kompleks adalah ketika objek yang akan dibangun terdiri dari objek lain yang berbeda yang diwakili oleh abstraksi.

Pertimbangkan menu di McDonald's. Menu berisi minuman, utama dan samping. Bergantung pada keturunan mana dari abstraksi individual dikomposisikan bersama, menu yang dibuat memiliki representasi lain.

1. Contoh: Cola, Big Mac, Kentang Goreng
2. Contoh: Sprite, Nuggets, Curly Fries

Di sana, kami mendapat dua contoh menu dengan representasi berbeda. Proses konstruksi pada gilirannya tetap sama. Anda membuat menu dengan minuman, utama dan samping.

Dengan menggunakan pola pembangun, Anda memisahkan algoritme pembuatan objek kompleks dari komponen berbeda yang digunakan untuk membuatnya.

Dalam hal pola pembangun, algoritma dienkapsulasi dalam direktur sedangkan pembangun digunakan untuk membuat bagian integral. Memvariasikan pembangun yang digunakan dalam algoritma hasil direktur dalam representasi yang berbeda karena bagian-bagian lain disusun untuk menu. Cara menu dibuat tetap sama.

Perbedaan utama di antara mereka adalah bahwa pola Builder terutama menggambarkan penciptaan objek kompleks selangkah demi selangkah. Dalam pola Pabrik Abstrak, penekanannya adalah pada keluarga produk-objek . Builder mengembalikan produk pada langkah terakhir . Sementara dalam pola Pabrik Abstrak produk tersedia segera .

Contoh: Misalkan kita membuat Labirin

1. Pabrik Abstrak:

Maze* MazeGame::CreateMaze (MazeFactory& factory) {
Maze* maze = factory.MakeMaze(); /// product is available at start!!
 /* Call some methods on maze */
return maze;
}

2. Builder:

Maze* MazeGame::CreateMaze (MazeBuilder& builder) {
builder.buildMaze(); /// We don't have access to maze
 /* Call some methods on builder */
return builder.GetMaze();
}

Saya percaya, penggunaan dan perbedaan antara pola Pabrik & Pembangun dapat dipahami / diklarifikasi dengan lebih mudah dalam periode waktu tertentu saat Anda bekerja pada basis kode yang sama dan mengubah persyaratan.

Dari pengalaman saya, biasanya, Anda mulai dengan pola Factory termasuk beberapa metode pembuat statis untuk menyembunyikan logika inisialisasi yang relatif kompleks. Ketika hierarki objek Anda menjadi lebih kompleks (atau ketika Anda menambahkan lebih banyak jenis, parameter), Anda mungkin berakhir memiliki metode Anda diisi dengan lebih banyak parameter dan belum lagi Anda harus mengkompilasi ulang modul Pabrik Anda. Semua hal itu, menambah kompleksitas metode pembuat Anda, mengurangi keterbacaan dan membuat modul pembuatan lebih rapuh.

Titik ini mungkin akan menjadi titik transisi / ekstensi. Dengan melakukannya, Anda membuat modul pembungkus di sekitar parameter konstruksi dan kemudian Anda akan dapat mewakili objek baru (serupa) dengan menambahkan beberapa abstraksi (mungkin) dan implementasi tanpa menyentuh logika kreasi Anda yang sebenarnya. Jadi Anda punya logika "kurang" kompleks.

Terus terang, merujuk pada semacam "memiliki objek yang dibuat dalam satu langkah atau beberapa langkah adalah perbedaan" karena satu-satunya faktor keragaman tidak cukup bagi saya untuk membedakan mereka karena saya bisa menggunakan kedua cara untuk hampir semua kasus yang saya hadapi. sekarang tanpa mengalami manfaat apa pun. Jadi inilah yang akhirnya saya pikirkan.

Keuntungan utama dari pola builder daripada pola pabrik adalah dalam kasus jika Anda ingin membuat beberapa objek standar dengan banyak penyesuaian yang mungkin, tetapi biasanya Anda hanya mengubah beberapa saja.

Misalnya, jika Anda ingin menulis Klien HTTP - Anda akan mengatur beberapa parameter default seperti batas waktu tulis / baca default, protokol, cache, DNS, interseptor, dll.

Sebagian besar pengguna klien Anda hanya akan menggunakan parameter default itu, sementara beberapa pengguna lain mungkin ingin menyesuaikan beberapa parameter lainnya. Dalam beberapa kasus, Anda hanya ingin mengubah batas waktu dan menggunakan sisanya seperti semula, sementara dalam kasus lain Anda mungkin perlu menyesuaikan misalnya cache.

Berikut adalah beberapa cara yang mungkin untuk membuat klien Anda (diambil dari OkHttpClient):

//just give me the default stuff
HttpClient.Builder().build()   

//I want to use custom cache
HttpClient.Builder().cache(MyCache()).build() 

//I want custom connection timeout
HttpClient.Builder().connectTimeout(30, TimeUnit.SECONDS).build() 

//I am more interested in read/write timeout
HttpClient.Builder()
        .readTimeout(30, TimeUnit.SECONDS)
        .writeTimeout(30, TimeUnit.SECONDS).build()

Jika Anda menggunakan pola pabrik untuk ini, pada akhirnya Anda akan menulis banyak metode dengan semua kemungkinan kombinasi parameter kreasi. Dengan builder, Anda cukup menentukan orang-orang yang Anda sayangi dan membiarkan builder membangunnya untuk Anda mengurus semua param lainnya.

Pola bangun menekankan pada kompleksitas menciptakan objek (diselesaikan dengan "langkah")

Pola abstrak menekankan "hanya" pada "abstraksi" objek (banyak tetapi terkait).

Perbedaannya jelas Dalam pola builder, builder akan membuat tipe objek spesifik untuk Anda. Anda harus memberi tahu apa yang harus dibangun oleh pembangun. Dalam pola pabrik, menggunakan kelas abstrak Anda langsung membangun objek tertentu.

Di sini builder class bertindak sebagai mediator antara kelas utama dan kelas tipe tertentu. Lebih banyak abstraksi.

Keduanya sangat mirip, tetapi jika Anda memiliki sejumlah besar parameter untuk pembuatan objek dengan beberapa di antaranya opsional dengan beberapa nilai default, pilih pola Builder.

Menurut opini saya

Builder adalah sejenis Pabrik yang lebih kompleks.

Namun dalam Builder Anda dapat membuat instance objek dengan menggunakan pabrik lain , yang diperlukan untuk membangun objek final dan valid.

Jadi, berbicara tentang evolusi "Pola Penciptaan" dengan kompleksitas Anda dapat memikirkannya dengan cara ini:

Dependency Injection Container -> Service Locator -> Builder -> Factory

Kedua pola datang untuk keperluan yang sama: Sembunyikan dari beberapa kode klien logika konstruksi dari objek yang kompleks. Tapi apa yang membuat "kompleks" (atau, terkadang, menyulitkan) objek? Terutama, itu karena dependensi, atau lebih tepatnya keadaan suatu objek yang disusun oleh keadaan yang lebih parsial. Anda dapat menyuntikkan dependensi oleh konstruktor untuk mengatur keadaan objek awal, tetapi suatu objek mungkin membutuhkan banyak dari mereka, beberapa akan berada dalam keadaan awal default (hanya karena kita harus belajar bahwa menetapkan dependensi default ke nol bukanlah cara yang paling bersih. ) dan beberapa lainnya diatur ke keadaan didorong oleh suatu kondisi. Selain itu, ada properti objek yang semacam "ketergantungan tidak menyadari" tetapi mereka juga dapat mengasumsikan status opsional.

ada dua cara terkenal untuk mendominasi kompleksitas itu:

• Komposisi / agregasi: Buat sebuah objek, buat objek dependennya, lalu satukan bersama. Di sini, pembangun dapat membuat proses yang menentukan aturan yang memimpin konstruksi komponen menjadi transparan dan fleksibel.

• Polimorfisme: Aturan konstruksi dideklarasikan langsung ke dalam definisi subtipe, jadi Anda memiliki seperangkat aturan untuk setiap subtipe dan beberapa kondisi memutuskan mana satu di antara seperangkat aturan ini berlaku untuk membangun objek. Sebuah pabrik sangat cocok dalam skenario ini.

Tidak ada yang menghalangi untuk menggabungkan kedua pendekatan ini. Sekelompok produk dapat membuat abstrak objek yang dilakukan dengan pembangun, pembangun dapat menggunakan pabrik untuk menentukan objek komponen mana yang dipakai.

Menurut pendapat saya, pola Builder digunakan ketika Anda ingin membuat objek dari sekelompok objek lain dan pembuatan bagian harus independen dari objek yang ingin Anda buat. Ini membantu untuk menyembunyikan pembuatan bagian dari klien untuk membuat pembangun dan klien independen. Ini digunakan untuk pembuatan objek kompleks (objek yang mungkin terdiri dari properti rumit)

Sementara pola pabrik menetapkan bahwa Anda ingin membuat objek dari keluarga yang sama dan Anda ingin dibuat secara bersamaan. Ini digunakan untuk objek yang lebih sederhana.

Pembangun dan Pabrik Abstrak

Pola desain Builder sangat mirip, pada tingkat tertentu, dengan pola Pabrik Abstrak. Itu sebabnya penting untuk membuat perbedaan antara situasi ketika satu atau yang lain digunakan. Dalam kasus Pabrik Abstrak, klien menggunakan metode pabrik untuk membuat objek sendiri. Dalam kasus Builder, kelas Builder diinstruksikan tentang cara membuat objek dan kemudian diminta untuk itu, tetapi cara kelas disatukan hingga kelas Builder, detail ini membuat perbedaan antara dua pola.

Antarmuka umum untuk produk

Dalam praktiknya produk-produk yang dibuat oleh pembangun beton memiliki struktur yang sangat berbeda, jadi jika tidak ada alasan untuk mendapatkan produk yang berbeda, kelas induk biasa. Ini juga membedakan pola Builder dari pola Abstrak Factory yang membuat objek yang berasal dari tipe umum.

Dari: http://www.oodesign.com/builder-pattern.html

Pola pabrik menciptakan implementasi konkret kelas saat runtime, yaitu maksud utamanya adalah menggunakan polimorfisme untuk memungkinkan subclass memutuskan kelas mana yang akan dipakai. Ini berarti pada waktu kompilasi kita tidak tahu kelas yang tepat yang akan dibuat, sementara pola Builder terutama berkaitan dengan penyelesaian masalah antiptern konstruktor telescoping, yang muncul karena sejumlah besar bidang opsional dari suatu kelas. Dalam pola pembangun tidak ada gagasan polimorfisme, seperti yang kita tahu objek apa yang kita coba bangun pada waktu kompilasi.

Satu-satunya tema umum dari kedua pola ini adalah menyembunyikan konstruktor dan pembuatan objek di balik metode pabrik, dan metode build, untuk konstruksi objek yang ditingkatkan.

Pola pabrik memungkinkan Anda membuat objek sekaligus sekaligus sementara pola builder memungkinkan Anda memecah proses pembuatan suatu objek. Dengan cara ini, Anda dapat menambahkan fungsionalitas yang berbeda selama pembuatan objek.