design patterns - बिल्डर डिजाइन पैटर्न और फैक्टरी डिजाइन पैटर्न के बीच क्या अंतर है?




design-patterns factory-pattern (18)

बिल्डर डिजाइन पैटर्न और फैक्टरी डिजाइन पैटर्न के बीच क्या अंतर है?

कौन सा फायदेमंद है और क्यों?

यदि मैं इन पैटर्नों का परीक्षण और तुलना / तुलना करना चाहता हूं तो मैं ग्राफ के रूप में अपने निष्कर्षों का प्रतिनिधित्व कैसे करूं?


IMHO

बिल्डर कुछ प्रकार की जटिल फैक्ट्री है।

लेकिन बिल्डर में आप अन्य कारखानों का उपयोग करने के साथ वस्तुओं को तुरंत चालू कर सकते हैं, जिन्हें अंतिम और वैध वस्तु बनाने की आवश्यकता होती है।

तो, जटिलता से "क्रिएशनल पैटर्न" विकास के बारे में बात करते हुए आप इस बारे में इस बारे में सोच सकते हैं:

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

अंतर स्पष्ट है बिल्डर पैटर्न में, निर्माता आपके लिए विशिष्ट प्रकार का ऑब्जेक्ट बनाएगा। आपको बताना होगा कि निर्माता को क्या बनाना है। कारखाने के पैटर्न में, अमूर्त वर्ग का उपयोग करके आप सीधे विशिष्ट वस्तु का निर्माण कर रहे हैं।

यहां बिल्डर वर्ग मुख्य वर्ग और विशिष्ट प्रकार के वर्गों के बीच मध्यस्थ के रूप में कार्य करता है। अधिक अमूर्तता


एक जटिल निर्माण तब होता है जब वस्तु का निर्माण किया जाना अलग-अलग अन्य वस्तुओं से बना होता है जो अवशेषों द्वारा दर्शाए जाते हैं।

मैकडॉनल्ड्स में एक मेनू पर विचार करें। एक मेनू में एक पेय, एक मुख्य और एक पक्ष होता है। आश्रित है कि व्यक्तिगत abstractions के वंशज एक साथ रचित हैं, बनाए गए मेनू का एक और प्रतिनिधित्व है।

  1. उदाहरण: कोला, बिग मैक, फ्रांसीसी फ्राइज़
  2. उदाहरण: स्प्राइट, नगेट्स, घुंघराले फ्राइज़

वहां हमें विभिन्न प्रस्तुतियों के साथ मेनू के दो उदाहरण मिले। बदले में निर्माण की प्रक्रिया वही बना है। आप एक पेय, एक मुख्य और एक पक्ष के साथ एक मेनू बनाते हैं।

बिल्डर पैटर्न का उपयोग करके आप इसे बनाने के लिए इस्तेमाल किए गए विभिन्न घटकों से एक जटिल वस्तु बनाने के एल्गोरिदम को अलग करते हैं।

बिल्डर पैटर्न के संदर्भ में एल्गोरिदम निर्देशक में encapsulated है जबकि बिल्डरों का अभिन्न अंग बनाने के लिए उपयोग किया जाता है। निदेशक के एल्गोरिदम में प्रयुक्त बिल्डर को अलग करना एक अलग प्रतिनिधित्व में परिणाम देता है क्योंकि अन्य भाग मेनू से बनाये जाते हैं। जिस तरह से मेनू बनाया गया है वही रहता है।


डिजाइन पैटर्न के साथ, आमतौर पर कोई "अधिक फायदेमंद" समाधान नहीं होता है जो सभी मामलों के लिए काम करता है। यह इस बात पर निर्भर करता है कि आपको क्या लागू करने की आवश्यकता है।

विकिपीडिया से:

  • बिल्डर कदम से एक जटिल वस्तु कदम बनाने पर केंद्रित है। सार फैक्टरी उत्पाद वस्तुओं के एक परिवार पर जोर देती है (या तो सरल या जटिल)। बिल्डर उत्पाद को अंतिम चरण के रूप में लौटाता है, लेकिन जहां तक ​​सार फैक्ट्री का संबंध है, उत्पाद तुरंत लौटा दिया जाता है।
  • बिल्डर अक्सर एक समग्र बनाता है।
  • अक्सर, डिजाइन फैक्ट्री विधि (कम जटिल, अधिक अनुकूलन योग्य, उपclasses बढ़ने) का उपयोग शुरू करते हैं और सार फैक्टरी, प्रोटोटाइप, या बिल्डर (अधिक लचीला, अधिक जटिल) के रूप में विकसित होते हैं क्योंकि डिजाइनर पता चलता है कि अधिक लचीलापन की आवश्यकता है।
  • कभी-कभी रचनात्मक पैटर्न पूरक होते हैं: बिल्डर अन्य घटकों में से एक का उपयोग कर सकते हैं ताकि यह लागू किया जा सके कि कौन से घटक बनते हैं। सार फैक्टरी, बिल्डर, और प्रोटोटाइप उनके कार्यान्वयन में सिंगलटन का उपयोग कर सकते हैं।

फैक्टरी डिजाइन पैटर्न के लिए विकिपीडिया प्रविष्टि: http://en.wikipedia.org/wiki/Factory_method_pattern

बिल्डर डिजाइन पैटर्न के लिए विकिपीडिया प्रविष्टि: http://en.wikipedia.org/wiki/Builder_pattern


दोनों बहुत समान हैं, लेकिन यदि आपके पास ऑब्जेक्ट सृजन के लिए बड़ी संख्या में पैरामीटर हैं, तो उनमें से कुछ डिफ़ॉल्ट मानों के साथ वैकल्पिक हैं, तो बिल्डर पैटर्न के लिए जाएं।


फैक्टरी पैटर्न आपको एक बार में एक ऑब्जेक्ट बनाने देता है जबकि बिल्डर पैटर्न आपको किसी ऑब्जेक्ट की निर्माण प्रक्रिया को तोड़ने देता है। इस तरह, आप किसी ऑब्जेक्ट के निर्माण के दौरान अलग-अलग कार्यक्षमता जोड़ सकते हैं।


फैक्ट्री पैटर्न रनटाइम पर एक वर्ग के ठोस कार्यान्वयन को बनाता है, यानी इसका मुख्य उद्देश्य बहुरूपता का उपयोग करना है ताकि उप-वर्गों को यह तय करने की अनुमति मिल सके कि कौन सी कक्षा को तुरंत चालू किया जाए। इसका मतलब है संकलन समय पर हम सटीक वर्ग को नहीं जानते हैं, जबकि बिल्डर पैटर्न मुख्य रूप से टेलीस्कोपिंग कन्स्ट्रक्टर एंटीपाटरर्न की समस्या को हल करने के लिए चिंतित है, जो कक्षा के वैकल्पिक क्षेत्रों की बड़ी संख्या के कारण उत्पन्न होता है। बिल्डर पैटर्न में बहुरूपता की कोई धारणा नहीं है, क्योंकि हम जानते हैं कि संकलन समय पर हम किस वस्तु का निर्माण करने की कोशिश कर रहे हैं।

इन दो पैटर्न का एकमात्र आम विषय रचनात्मक वस्तुओं और कारखाने के तरीकों के पीछे ऑब्जेक्ट सृजन, और बेहतर वस्तु निर्माण के लिए निर्माण विधि के छिपाने का है।


बिल्डर और फैक्ट्री के बीच एक हड़ताली अंतर जो मैं कर सकता था वह निम्नलिखित था

मान लीजिए कि हमारे पास एक कार है

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

उपर्युक्त इंटरफ़ेस में हम निम्नलिखित तरीके से कार प्राप्त कर सकते हैं:

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

लेकिन क्या होगा, सीट बनाने के दौरान कुछ अपवाद होता है ??? आप सभी // लेकिन पर उद्देश्य प्राप्त नहीं करेंगे

मान लीजिए कि आपके पास निम्नलिखित की तरह कार्यान्वयन है

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

अब आप इस तरह बना सकते हैं

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

  }

यहां दूसरे मामले में, भले ही एक ऑपरेशन विफल हो जाए, फिर भी आपको कार मिल जाएगी।

हो सकता है कि कार पूरी तरह से बाद में काम नहीं करेगी, लेकिन आपके पास ऑब्जेक्ट होगा।

क्योंकि फैक्टरी विधि आपको कार को एकल कॉल में देती है, जबकि बिल्डर एक-एक करके बनाता है।

हालांकि, यह इस बात पर निर्भर करता है कि किसके लिए जाना है।


बिल्डर डिज़ाइन पैटर्न एक ऑब्जेक्ट का वर्णन करता है जो जानता है कि कई चरणों में किसी विशिष्ट प्रकार के किसी अन्य ऑब्जेक्ट को कैसे तैयार किया जाए। इसमें प्रत्येक मध्यवर्ती चरण में लक्षित आइटम के लिए आवश्यक स्थिति होती है। सोचें कि स्ट्रिंगबिल्डर एक अंतिम स्ट्रिंग का उत्पादन करने के लिए क्या करता है।

फैक्ट्री डिज़ाइन पैटर्न एक ऑब्जेक्ट का वर्णन करता है जो जानता है कि एक चरण में कई अलग-अलग लेकिन संबंधित प्रकार के ऑब्जेक्ट कैसे बनाएं, जहां दिए गए पैरामीटर के आधार पर विशिष्ट प्रकार चुना जाता है। सीरियलाइजेशन सिस्टम के बारे में सोचें, जहां आप अपना सीरियलाइज़र बनाते हैं और यह एक लोड कॉल में ऑब्जेक्ट में वांछित बनाता है।


बिल्डर पैटर्न और फैक्टरी पैटर्न समान लगता है क्योंकि वे दोनों आपके लिए ऑब्जेक्ट बनाते हैं।

आपको करीब देखने की जरूरत है

यह वास्तविक जीवन उदाहरण दो और स्पष्ट के बीच अंतर बनाएगा।

आप फास्ट फूड रेस्तरां में गए और आप भोजन का आदेश देते हैं।

1) क्या खाना?

पिज़्ज़ा

2) क्या टॉपिंग्स?

कैप्सिकम, टमाटर, बीबीक्यू चिकन, कोई पिनप्ले नहीं

फैक्ट्री पैटर्न द्वारा विभिन्न प्रकार के खाद्य पदार्थ बनाए जाते हैं लेकिन एक विशेष भोजन के विभिन्न रूप बिल्डर पैटर्न द्वारा किए जाते हैं।

विभिन्न प्रकार के खाद्य पदार्थ

पिज्जा, बर्गर, पास्ता

पिज्जा के रूपों

केवल पनीर, पनीर + टमाटर + कैप्सिकम, पनीर + टमाटर इत्यादि।

कोड नमूना

आप यहां दोनों पैटर्न के नमूना कोड कार्यान्वयन देख सकते हैं
बिल्डर पैटर्न
फैक्टरी पैटर्न


मेरी राय में बिल्डर पैटर्न का उपयोग तब किया जाता है जब आप किसी ऑब्जेक्ट को अन्य ऑब्जेक्ट्स के समूह से बनाना चाहते हैं और भाग के निर्माण को उस ऑब्जेक्ट से स्वतंत्र होना चाहिए जिसे आप बनाना चाहते हैं। यह बिल्डर और क्लाइंट को स्वतंत्र बनाने के लिए ग्राहक से भाग के निर्माण को छिपाने में मदद करता है। इसका उपयोग जटिल वस्तुओं के निर्माण के लिए किया जाता है (वस्तुओं जिसमें जटिल गुण हो सकते हैं)

जबकि फैक्ट्री पैटर्न निर्दिष्ट करता है कि आप एक आम परिवार की वस्तुओं को बनाना चाहते हैं और आप इसे एक बार में सीरेट करना चाहते हैं। यह सरल वस्तुओं के लिए प्रयोग किया जाता है।


यह एक रचनात्मक पैटर्न है क्योंकि इसका उपयोग क्लास इंस्टेंटेशन को नियंत्रित करने के लिए किया जाता है। बिल्डर पैटर्न का उपयोग घटक भागों के साथ जटिल वस्तुओं को बनाने के लिए किया जाता है जिन्हें एक ही क्रम में बनाया जाना चाहिए या एक विशिष्ट एल्गोरिदम का उपयोग करना चाहिए। निर्देशक के रूप में जाना जाने वाला एक बाहरी वर्ग, निर्माण एल्गोरिदम को नियंत्रित करता है।

नमूना

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace ConsoleApp_Design_Patterns
{

    class BuilderDesignPattern
    {
        static void Main(string[] args)
        {
            //create a constructor object to start building
            Kid aKid = new Kid();
            aKid.Name = "Elizabeth";

            //Elizabeth use Monkey mold to make a monkey
            Console.WriteLine("{0} start making a monkey", aKid.Name);
            AnimalBuilder builderA = new MonkeyBuilder();
            aKid.MakeAnimal(builderA);
            builderA.aAnimal.ShowMe();

            //Elizabeth use Kitten mold to make a kitten
            Console.WriteLine("{0} start making a kitten", aKid.Name);
            AnimalBuilder builderB = new KittenBuilder();
            aKid.MakeAnimal(builderB);
            builderB.aAnimal.ShowMe();

            Console.Read();
        }
    }
    public abstract class AnimalBuilder
    {
        public Animal aAnimal;

        public abstract void BuildAnimalHeader();
        public abstract void BuildAnimalBody();
        public abstract void BuildAnimalLeg();
        public abstract void BuildAnimalArm();
        public abstract void BuildAnimalTail();
    }
    public class MonkeyBuilder : AnimalBuilder
    {

        public MonkeyBuilder()
        {
            aAnimal = new Monkey();
        }

        public override void BuildAnimalHeader()
        {
            aAnimal.Head = "Moneky's Head has been built";
        }

        public override void BuildAnimalBody()
        {
            aAnimal.Body = "Moneky's Body has been built";
        }

        public override void BuildAnimalLeg()
        {
            aAnimal.Leg = "Moneky's Leg has been built";
        }

        public override void BuildAnimalArm()
        {
            aAnimal.Arm = "Moneky's Arm has been built";
        }

        public override void BuildAnimalTail()
        {
            aAnimal.Tail = "Moneky's Tail has been built";
        }
    }
    public class KittenBuilder : AnimalBuilder
    {
        public KittenBuilder()
        {
            aAnimal = new Kitten();
        }

        public override void BuildAnimalHeader()
        {
            aAnimal.Head = "Kitten's Head has been built";
        }

        public override void BuildAnimalBody()
        {
            aAnimal.Body = "Kitten's Body has been built";
        }

        public override void BuildAnimalLeg()
        {
            aAnimal.Leg = "Kitten's Leg has been built";
        }

        public override void BuildAnimalArm()
        {
            aAnimal.Arm = "Kitten's Arm has been built";
        }

        public override void BuildAnimalTail()
        {
            aAnimal.Tail = "Kitten's Tail has been built";
        }
    }
    public abstract class Animal
    {
        public string Head { get; set; }
        public string Body { get; set; }
        public string Leg { get; set; }
        public string Arm { get; set; }
        public string Tail { get; set; }


        //helper method for demo the Polymorphism, so we can 
        //easily tell what type object it is from client.
        public abstract void Eat();

        //helper method for demo the result from client
        public void ShowMe()
        {
            Console.WriteLine(Head);
            Console.WriteLine(Body);
            Console.WriteLine(Leg);
            Console.WriteLine(Arm);
            Console.WriteLine(Tail);
            Eat();

        }
    }
    public class Monkey : Animal
    {
        //helper method to show monkey's property for demo purpose
        public override void Eat()
        {
            Console.WriteLine("Since I am Monkey, I like to eat banana");
        }
    }
    public class Kitten : Animal
    {
        public override void Eat()
        {
            Console.WriteLine("Since I am Kitten, I like to eat kitten food");
        }
    }
    public class Kid
    {
        public string Name { get; set; }

        //construct process to build an animal object, 
        //after this process completed, a object 
        //will be consider as a ready to use object.
        public void MakeAnimal(AnimalBuilder aAnimalBuilder)
        {
            aAnimalBuilder.BuildAnimalHeader();
            aAnimalBuilder.BuildAnimalBody();
            aAnimalBuilder.BuildAnimalLeg();
            aAnimalBuilder.BuildAnimalArm();
            aAnimalBuilder.BuildAnimalTail();
        }


    }
}

सार कारखाना बिल्डर के समान है जिसमें यह जटिल वस्तुओं का निर्माण भी कर सकता है। प्राथमिक अंतर यह है कि बिल्डर पैटर्न चरणबद्ध रूप से जटिल ऑब्जेक्ट चरण बनाने पर केंद्रित है। सार कारक का जोर उत्पाद वस्तुओं के परिवारों (या तो सरल या जटिल) पर है।


सार फैक्टरी और बिल्डर पैटर्न दोनों रचनात्मक पैटर्न हैं लेकिन विभिन्न इरादों के साथ।

सार फैक्टरी पैटर्न संबंधित वस्तुओं के परिवारों के लिए वस्तु निर्माण पर जोर देता है जहां:

  • प्रत्येक परिवार एक सामान्य बेस क्लास / इंटरफेस से प्राप्त कक्षाओं का एक सेट है।
  • एक कॉल के परिणामस्वरूप प्रत्येक ऑब्जेक्ट तुरंत लौटा दिया जाता है।

बिल्डर पैटर्न चरण द्वारा जटिल ऑब्जेक्ट चरण बनाने पर केंद्रित है। यह जटिल वस्तु के निर्माण की प्रक्रिया से प्रतिनिधित्व को अस्वीकार करता है, ताकि अलग-अलग प्रतिनिधित्वों के लिए एक ही निर्माण प्रक्रिया का उपयोग किया जा सके।

  • बिल्डर ऑब्जेक्ट जटिल ऑब्जेक्ट की कॉन्फ़िगरेशन को समाहित करता है।
  • निदेशक वस्तु बिल्डर का उपयोग करने के प्रोटोकॉल को जानता है, जहां प्रोटोकॉल जटिल वस्तु बनाने के लिए आवश्यक सभी तार्किक चरणों को परिभाषित करता है।

एक कारखाना बस एक कन्स्ट्रक्टर के आसपास एक रैपर समारोह है (संभवतः एक अलग वर्ग में एक)। मुख्य अंतर यह है कि एक फैक्ट्री विधि पैटर्न को पूरे ऑब्जेक्ट को एकल विधि कॉल में बनाने की आवश्यकता होती है, जिसमें सभी पैरामीटर एक ही पंक्ति में पास होते हैं। अंतिम वस्तु वापस कर दी जाएगी।

दूसरी ओर, एक निर्माता पैटर्न , सभी संभावित मानकों के आस-पास एक रैपर ऑब्जेक्ट है जो आप एक कन्स्ट्रक्टर आमंत्रण में पारित करना चाहते हैं। यह आपको धीरे-धीरे अपनी पैरामीटर सूची बनाने के लिए सेटटर विधियों का उपयोग करने की अनुमति देता है। बिल्डर क्लास पर एक अतिरिक्त विधि एक बिल्ड () विधि है, जो बिल्डर ऑब्जेक्ट को वांछित कन्स्ट्रक्टर में पास करती है, और परिणाम देता है।

जावा जैसी स्थिर भाषाओं में, यह अधिक महत्वपूर्ण हो जाता है जब आपके पास कुछ हद तक (संभावित रूप से वैकल्पिक) पैरामीटर होते हैं, क्योंकि यह पैरामीटर के सभी संभावित संयोजनों के लिए दूरबीन रचनाकारों की आवश्यकता से बचा जाता है। इसके अलावा एक निर्माता आपको केवल पढ़ने वाले या निजी फ़ील्ड को परिभाषित करने के लिए सेटर विधियों का उपयोग करने की अनुमति देता है जिसे कन्स्ट्रक्टर के कॉल के बाद सीधे संशोधित नहीं किया जा सकता है।

मूल फैक्टरी उदाहरण

// 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");

बेसिक बिल्डर उदाहरण

// 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();

इन दो विकिपीडिया पृष्ठों से कोड नमूने की तुलना करना उचित हो सकता है:

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


बिल्डिंग ऑब्जेक्ट ऑब्जेक्ट बनाने की जटिलता पर जोर देती है ("चरणों" द्वारा हल)

सार पैटर्न (एकाधिक लेकिन संबंधित) वस्तुओं के "abstraction" पर "बस" पर जोर देता है।


+-------------------------------------------------------------------+---------------------------------------------------+
|                              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                           |
+-------------------------------------------------------------------+---------------------------------------------------+  

टेलीस्कोपिंग कन्स्ट्रक्टर पैटर्न

सादृश्य:

  • फैक्टरी: एक रेस्तरां पर विचार करें। "आज का भोजन" का निर्माण एक कारखाना पैटर्न है, क्योंकि आप रसोईघर को "मुझे आज का भोजन प्राप्त करें" बताते हैं और रसोई (फैक्ट्री) छुपा मानदंडों के आधार पर उत्पन्न होने वाली वस्तु का निर्णय लेता है।
  • बिल्डर: यदि आप कस्टम पिज्जा ऑर्डर करते हैं तो बिल्डर दिखाई देता है। इस मामले में, वेटर शेफ (निर्माता) को बताता है "मुझे एक पिज्जा चाहिए; इसमें पनीर, प्याज और बेकन जोड़ें!" इस प्रकार, निर्माता उत्पन्न वस्तु के गुणों को उजागर करता है, लेकिन उन्हें सेट करने के तरीके को छुपाता है।

Courtesy


  • चरण द्वारा एक जटिल वस्तु चरण का निर्माण: निर्माता पैटर्न

  • एक विधि का उपयोग करके एक साधारण वस्तु बनाई जाती है: फैक्ट्री विधि पैटर्न

  • एकाधिक फैक्टरी विधि का उपयोग करके ऑब्जेक्ट बनाना: सार कारखाना पैटर्न





builder-pattern