design patterns - फैक्टरी और सार फैक्टरी पैटर्न के बीच बुनियादी अंतर क्या है?




design-patterns factory (14)

इस जानकारी के लिए स्रोत: http://java.dzone.com/news/intro-design-patterns-abstract

सार फैक्टरी बनाम फैक्टरी विधि

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

सार फैक्टरी पैटर्न में एक सार फैक्ट्री, कंक्रीट फैक्ट्री, सार उत्पाद, कंक्रीट उत्पाद और ग्राहक शामिल हैं।

कैसे कार्यान्वित करें

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

कारखाना विधि पैटर्न सार फैक्टरी पैटर्न का एक सरलीकृत संस्करण है। कारखाना विधि पैटर्न एक परिवार से संबंधित उत्पादों को बनाने के लिए ज़िम्मेदार है, जबकि सार कारखाना पैटर्न उत्पादों के कई परिवारों के साथ सौदा करता है।

फैक्टरी विधि जनरेटर वर्ग और परिणामी उत्पादों से क्लाइंट को कम करने के लिए इंटरफेस और अमूर्त कक्षाओं का उपयोग करती है। सार फैक्ट्री में एक जनरेटर है जो कई कारखाने के तरीकों के लिए एक कंटेनर है, साथ ही जनरेटर और उत्पादों से ग्राहक को डीकॉप्लिंग करने वाले इंटरफेस के साथ।

फैक्टरी विधि पैटर्न का उपयोग कब करें

किसी विशेष उत्पाद से क्लाइंट को डीक्यूपल करने की आवश्यकता होने पर फैक्टरी विधि पैटर्न का उपयोग करें। किसी उत्पाद के उदाहरण बनाने और कॉन्फ़िगर करने के लिए ज़िम्मेदारी के ग्राहक को राहत देने के लिए फैक्टरी विधि का उपयोग करें।

सार फैक्टरी पैटर्न का उपयोग कब करें

जब उत्पाद वर्गों से ग्राहकों को डीकॉप्ल किया जाना चाहिए तो सार फैक्टरी पैटर्न का उपयोग करें। कार्यक्रम विन्यास और संशोधन के लिए विशेष रूप से उपयोगी। सार फैक्टरी पैटर्न बाधाओं को भी लागू कर सकता है कि किस वर्ग के साथ दूसरों के साथ उपयोग किया जाना चाहिए। नई ठोस कारखानों को बनाने के लिए यह बहुत काम हो सकता है।

उदाहरण:

सार फैक्टरी उदाहरण 1

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

सार फैक्टरी उदाहरण 2:

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

फैक्टरी विधि उदाहरण:

खिलौना कंपनी निर्माता से मेल खाती है, क्योंकि यह उत्पाद वस्तुओं को बनाने के लिए कारखाने का उपयोग कर सकती है। खिलौना कंपनी का विभाजन जो एक विशिष्ट प्रकार का खिलौना (घोड़ा या कार) बनाती है, कंक्रीट निर्माता से मेल खाता है।

फैक्टरी और सार फैक्टरी पैटर्न के बीच बुनियादी अंतर क्या है?


सार फैक्टरी पैटर्न

  • संबंधित या आश्रित वस्तुओं के परिवारों को उनके ठोस वर्ग निर्दिष्ट किए बिना एक इंटरफ़ेस प्रदान करें।

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

  • दरअसल, प्रतिनिधि वस्तु तत्काल निष्पादन करने के लिए कारखाने के तरीकों का उपयोग करती है!

फैक्टरी पैटर्न

  • फैक्टरी पैटर्न रचनात्मक पैटर्न के उदाहरण हैं

  • क्रिएशनल पैटर्न ऑब्जेक्ट इंस्टेंटेशन प्रक्रिया को अमूर्त करते हैं। वे छुपाते हैं कि वस्तुएं कैसे बनाई जाती हैं और समग्र प्रणाली को स्वतंत्र बनाने में मदद करती है कि इसकी वस्तुओं को कैसे बनाया और बनाया गया है।

  • क्लास क्रिएशनल पैटर्न ऑब्जेक्ट को फैक्ट्री विधि को तुरंत चालू करने के लिए विरासत के उपयोग पर ध्यान केंद्रित करते हैं

  • ऑब्जेक्ट क्रिएशनल पैटर्न किसी अन्य ऑब्जेक्ट सार फैक्टरी के लिए तत्कालता के प्रतिनिधिमंडल पर ध्यान केंद्रित करते हैं

संदर्भ: फैक्टरी बनाम सार फैक्टरी


एक फैक्टरी विधि एक गैर-व्यवस्थित विधि है जो बेस क्लास या इंटरफ़ेस प्रकार देता है और इसे पॉलिमॉर्फिक सृजन को सक्षम करने के लिए पदानुक्रम में कार्यान्वित किया जाता है। एक फैक्टरी विधि को कक्षा के एक या एक से अधिक उप-वर्गों द्वारा परिभाषित / कार्यान्वित किया जाना चाहिए। वर्ग और सबक्लास प्रत्येक कारखाने के रूप में कार्य करता है। हालांकि, हम यह नहीं कहते कि फैक्ट्री विधि एक फैक्ट्री है। एक सार फैक्ट्री अपने ठोस वर्गों को निर्दिष्ट किए बिना संबंधित या आश्रित वस्तुओं के परिवार बनाने के लिए एक इंटरफेस है।

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


कारखाना पैटर्न: कारखाना आईपॉडक्ट-कार्यान्वयन पैदा करता है

सार फैक्टरी पैटर्न: एक फैक्ट्री फैक्ट्री आईफैक्ट्रीज़ बनाती है, जो बदले में आईपॉडक्ट्स बनाती है :)

[टिप्पणियों के अनुसार अद्यतन]
जो मैंने पहले लिखा था वह कम से कम विकिपीडिया के अनुसार सही नहीं है। एक अमूर्त कारखाना बस एक कारखाना इंटरफ़ेस है। इसके साथ, आप अलग-अलग संदर्भों में विभिन्न कारखानों को अनुमति देने के लिए, अपने कारखानों को रनटाइम पर स्विच कर सकते हैं। विभिन्न ओएस, एसक्यूएल प्रदाताओं, मिडलवेयर-ड्राइवर आदि के लिए उदाहरण अलग-अलग कारखानों के लिए हो सकते हैं ..


परिभाषा के अनुसार हम दो के अंतर खींच सकते हैं:

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

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

तो, उपरोक्त परिभाषाओं में हम एक विशेष अंतर पर जोर दे सकते हैं। यानी, फैक्टरी पैटर्न ऑब्जेक्ट्स बनाने के लिए ज़िम्मेदार है और सार फैक्ट्री संबंधित वस्तुओं का एक सेट बनाने के लिए ज़िम्मेदार है; स्पष्ट रूप से एक इंटरफेस के माध्यम से दोनों।

कारखाना पैटर्न:

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

सार फैक्टरी पैटर्न:

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

बहुत से लोग शायद आश्चर्यचकित होंगे, लेकिन यह सवाल गलत है । यदि आप साक्षात्कार के दौरान यह प्रश्न सुनते हैं, तो आपको साक्षात्कारकर्ता को यह समझने में मदद करने की आवश्यकता है कि भ्रम कहां है।

आइए इस तथ्य से शुरू करें कि कोई ठोस पैटर्न नहीं है जिसे केवल "फैक्टरी" कहा जाता है। पैटर्न है जिसे "सार फैक्टरी" कहा जाता है, और वहां पैटर्न है जिसे "फैक्टरी विधि" कहा जाता है।

तो, "फैक्टरी" का मतलब क्या है? निम्नलिखित में से एक (संदर्भ के दायरे के आधार पर सभी को सही माना जा सकता है):

  • कुछ लोग इसे " सार फैक्ट्री " के लिए उपनाम (शॉर्टकट) के रूप में उपयोग करते हैं।
  • कुछ लोग इसे " फैक्टरी विधि " के लिए उपनाम (शॉर्टकट) के रूप में उपयोग करते हैं।
  • कुछ लोग इसे सभी फैक्ट्री / क्रिएशनल पैटर्न के लिए अधिक सामान्य नाम के रूप में उपयोग करते हैं। जैसे "सार फैक्टरी" और "फैक्टरी विधि" दोनों कारखाने हैं।

और, दुर्भाग्यवश , कई लोग कारखाने या कारखानों (या उनके इंटरफेस) बनाने वाले अन्य प्रकार के फैक्ट्री को दर्शाने के लिए "फैक्ट्री" का उपयोग करते हैं। उनके सिद्धांत के आधार पर:

उत्पाद आईपॉडक्ट लागू करता है, जो फैक्ट्री द्वारा बनाया गया है, जो आईफैक्टरी को लागू करता है, जो सार फैक्ट्री द्वारा बनाई गई है।

यह समझने के लिए कि यह कितना मूर्खतापूर्ण है, आइए अपना समीकरण जारी रखें:

सार फैक्टरी लागू IAbstractFactory, जो द्वारा बनाई गई है ... सार सार तत्व फैक्टरी ???

मुझे आशा है कि आप बिंदु देखेंगे। भ्रमित न हों, और कृपया उन चीजों का आविष्कार न करें जो कारण के लिए मौजूद नहीं हैं।

-

पीएस : उत्पादों के लिए फैक्टरी सार कारखाना है, और सार कारखानों के लिए फैक्टरी सार तत्वों का एक और उदाहरण भी होगा।


मेरे स्रोत हैं: , tutorialspoint.com , programmers.stackexchange.com और CodeProject.com

Factory Method ( Factory Method भी कहा जाता है) एक Interface कार्यान्वयन के decouple ग्राहक के लिए है। नमूने के लिए हमारे पास दो Circle और Square कार्यान्वयन के साथ एक Shape इंटरफ़ेस है। हमने फ़ैक्टरी विधि के साथ फैक्ट्री क्लास को एक निर्धारक पैरामीटर के साथ परिभाषित किया है जैसे Shape और Shape इंटरफ़ेस के नए संबंधित कार्यान्वयन।

Abstract Factory में कई कारखाने के कार्यान्वयन द्वारा कई फैक्ट्री विधि या फैक्ट्री इंटरफ़ेस शामिल हैं। अगले उपरोक्त नमूने के लिए हमारे पास दो Red और Yellow कार्यान्वयन के साथ एक Color इंटरफ़ेस है। हमने दो RedCircleFactory ShapeColorFactory इंटरफेस को दो RedCircleFactory और YellowSquareFactory RedCircleFactory साथ परिभाषित किया है। इस अवधारणा को समझाने के लिए निम्नलिखित कोड:

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

FactoryMethod और AbstractFactory FactoryMethod बीच यहां अंतर। Factory Method बस एक इंटरफ़ेस की एक ठोस कक्षा को वापस करने के लिए, लेकिन Abstract Factory रिटर्न factory of factory । दूसरे शब्दों में Abstract Factory इंटरफेस की एक श्रृंखला के विभिन्न गठबंधन लौटती है।

मुझे आशा है कि मेरी व्याख्या उपयोगी होगी।


यहां देखें: http://www.allapplabs.com/java_design_patterns/abstract_factory_pattern.htm ऐसा लगता है कि फैक्टरी विधि बेस क्लास के रूप में एक विशेष वर्ग (अमूर्त नहीं) का उपयोग करती है जबकि सार कारखाना इसके लिए एक सार वर्ग का उपयोग करता है। इसके अलावा यदि अमूर्त वर्ग के बजाय इंटरफ़ेस का उपयोग करना परिणाम सार फैक्टरी पैटर्न का एक अलग कार्यान्वयन होगा।

: डी


सार फैक्टरी विभिन्न प्रकार के इंटरफेस बनाने के लिए टेम्पलेट है। Suppose you have project that requires you to parse different types of csv files containing quantity, price and item specific information like some contain data about fruits other about chocolates and then after parsing you need to update this information in their corresponding database so now you can have one abstract factory returning you parser and modifier factory and then this parser factory can return you Chocolate parser object,Fruit Parser Object etc. and similarly Modifier Factory can return Chocolate modifier object , Fruit Modifier object etc.


सार फैक्ट्री संबंधित वस्तुओं को बनाने के लिए एक इंटरफ़ेस है लेकिन फैक्ट्री विधि एक विधि है। कारखाना विधि द्वारा सार कारखाना लागू किया जाता है।


जॉन फेमिनेला का विस्तार जवाब:

Apple , Banana , Cherry FruitFactory लागू FruitFactory और इसमें एक विधि कहा जाता है जिसे ऐप्पल या केले या चेरी बनाने का पूरी तरह उत्तरदायी होता है। आप अपनी Factory विधि के साथ कर रहे हैं।

अब, आप अपने फलों से एक विशेष सलाद Create चाहते हैं और आपकी सार फैक्ट्री आती है। सार फैक्टरी जानता है कि ऐप्पल, केला और चेरी से अपने विशेष सलाद को कैसे बनाया जाए।

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

फैक्टरी विधि: आपके पास एक कारखाना है जो किसी विशेष आधार वर्ग से प्राप्त वस्तुओं को बनाता है

सार कारखाना: आपके पास एक कारखाना है जो अन्य कारखानों का निर्माण करता है, और इन कारखानों में बदले में आधार वर्गों से प्राप्त वस्तुओं को बनाते हैं। आप ऐसा इसलिए करते हैं क्योंकि आप अक्सर एक वस्तु (जैसे फैक्टरी विधि के साथ) बनाना नहीं चाहते हैं - बल्कि, आप संबंधित वस्तुओं का संग्रह बनाना चाहते हैं।


I think we can understand the difference between these two by seeing a Java8 example code:

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

}

Now the question is which way of creation should you use and why: The first way (no pattern, just plain constructor): creating by yourself is not a good idea, you have to do all the work, and your client code is tied to the particular implementation.

The second way (using Factory pattern): provides you the benefit that you can pass any type of implementation, which can provide different type of something based on some condition (maybe a parameter passed to creational method).

The third way (using Abstract Factory pattern): This gives you more flexibility. You can find different types of creators of something based on some condition (maybe a parameter passed).

ध्यान दें कि आप हमेशा दो स्थितियों को जोड़कर फैक्टरी पैटर्न से दूर हो सकते हैं (जो कोड जटिलता और युग्मन को थोड़ा बढ़ाता है), मुझे लगता है कि हम शायद ही कभी सार फैक्टरी पैटर्न के वास्तविक जीवन उपयोग के मामलों को देखते हैं।


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

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

तो यहां PizzaIngredientsFactory फैक्ट्री एक अमूर्त कारखाना है क्योंकि यह संबंधित उत्पादों के परिवार को बनाने के तरीकों को प्रदान करता है।

ध्यान दें कि सार कारखाने में प्रत्येक विधि स्वयं में एक फैक्टरी विधि है। createDough() की तरह ही एक फैक्ट्री विधि है जिसका कंक्रीट कार्यान्वयन NYPizzaIngredientsFactory जैसे उप-वर्गों द्वारा प्रदान किया जाएगा। तो इस प्रत्येक अलग-अलग स्थान का उपयोग करके उनके स्थान से संबंधित ठोस सामग्री के उदाहरण पैदा हो सकते हैं।

फैक्टरी विधि

ठोस कार्यान्वयन का उदाहरण प्रदान करता है

उदाहरण में:
- createDough() - आटा के लिए ठोस कार्यान्वयन प्रदान करता है। तो यह एक कारखाना विधि है

सार फैक्टरी

संबंधित वस्तुओं के परिवार बनाने के लिए इंटरफ़ेस प्रदान करता है

उदाहरण में:
- PizzaIngredientsFactory एक अमूर्त कारखाना है क्योंकि यह Dough , Clams , Sauce जैसी वस्तुओं का एक संबंधित सेट बनाने की अनुमति देता है। वस्तुओं के प्रत्येक परिवार को बनाने के लिए यह एक कारखाना विधि प्रदान करता है।

हेड फर्स्ट डिज़ाइन पैटर्न से उदाहरण





factory-method