डिजाइन पैटर्न: फैक्टरी विधि

नमस्ते! आज हम डिज़ाइन पैटर्न का अध्ययन करना जारी रखेंगे और फ़ैक्टरी विधि पैटर्न पर चर्चा करेंगे। आपको पता चलेगा कि यह क्या है और यह पैटर्न किन कार्यों के लिए उपयुक्त है। हम इस डिजाइन पैटर्न पर व्यवहार में विचार करेंगे और इसकी संरचना का अध्ययन करेंगे। यह सुनिश्चित करने के लिए कि सब कुछ स्पष्ट है, आपको निम्नलिखित विषयों को समझने की आवश्यकता है:

1. जावा में वंशानुक्रम।
2. जावा में सार तरीके और कक्षाएं

फ़ैक्टरी विधि किस समस्या का समाधान करती है?

सभी फ़ैक्टरी डिज़ाइन पैटर्न में दो प्रकार के प्रतिभागी होते हैं: निर्माता (स्वयं कारखाने) और उत्पाद (कारखानों द्वारा बनाई गई वस्तुएँ)। निम्नलिखित स्थिति की कल्पना करें: हमारी एक फैक्ट्री है जो CodeGym-ब्रांडेड कारों का उत्पादन करती है। यह विभिन्न प्रकार के निकायों के साथ कारों के मॉडल बनाना जानता है:

• सेडान
• स्टेशन वैगन
• कूपों

हमारा व्यवसाय इतना समृद्ध हुआ कि एक दिन हमने एक और कार निर्माता - वनऑटो का अधिग्रहण कर लिया। समझदार व्यवसाय स्वामी होने के नाते, हम किसी भी OneAuto ग्राहक को खोना नहीं चाहते हैं, और इसलिए हमें उत्पादन के पुनर्गठन के कार्य का सामना करना पड़ रहा है ताकि हम उत्पादन कर सकें:

• CodeGym सेडान
• CodeGym स्टेशन वैगन
• कोडजिम कूप
• वनऑटो सेडान
• वनऑटो स्टेशन वैगन
• वनऑटो कूप

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

फैक्ट्री पैटर्न के बारे में थोड़ा सा

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

public class Coffee {
    public void grindCoffee(){
        // Grind the coffee
    }
    public void makeCoffee(){
        // Brew the coffee
    }
    public void pourIntoCup(){
        // Pour into a cup
    }
}

और विशिष्ट प्रकार की कॉफी के अनुरूप कई बाल वर्ग जो हमारे कारखाने का उत्पादन कर सकते हैं:

public class Americano extends Coffee {}
public class Cappuccino extends Coffee {}
public class CaffeLatte extends Coffee {}
public class Espresso extends Coffee {}

ऑर्डर देना आसान बनाने के लिए हमने एक एनम बनाया है:

public enum CoffeeType {
    ESPRESSO,
    AMERICANO,
    CAFFE_LATTE,
    CAPPUCCINO
}

कॉफी फैक्ट्री खुद कुछ इस तरह दिखती थी:

public class SimpleCoffeeFactory {
    public Coffee createCoffee(CoffeeType type) {
        Coffee coffee = null;

        switch (type) {
            case AMERICANO:
                coffee = new Americano();
                break;
            case ESPRESSO:
                coffee = new Espresso();
                break;
            case CAPPUCCINO:
                coffee = new Cappuccino();
                break;
            case CAFFE_LATTE:
                coffee = new CaffeLatte();
                break;
        }
        
        return coffee;
    }
}

और अंत में, कॉफी शॉप ही इस तरह दिखी:

public class CoffeeShop {

    private final SimpleCoffeeFactory coffeeFactory;

    public CoffeeShop(SimpleCoffeeFactory coffeeFactory) {
        this.coffeeFactory = coffeeFactory;
    }

    public Coffee orderCoffee(CoffeeType type) {
        Coffee coffee = coffeeFactory.createCoffee(type);
        coffee.grindCoffee();
        coffee.makeCoffee();
        coffee.pourIntoCup();

        System.out.println("Here's your coffee! Thanks! Come again!");
        return coffee;
    }
}

एक साधारण कारखाने का आधुनिकीकरण

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

• इतालवी कॉफी शॉप में, हम विशेष रूप से पीसने और भूनने के साथ विशेष रूप से इतालवी कॉफी ब्रांडों का उपयोग करेंगे।
• अमेरिकी स्थान में बड़े हिस्से होंगे, और हम प्रत्येक आदेश के साथ मार्शमॉलो की सेवा करेंगे।

केवल एक चीज जो अपरिवर्तित रहती है, वह है हमारा बिजनेस मॉडल, जिसने खुद को उत्कृष्ट साबित किया है। कोड के संदर्भ में, यही होता है। हमारे उत्पादों के अनुरूप हमारे पास 4 वर्ग थे:

public class Americano extends Coffee {}
public class Cappuccino extends Coffee {}
public class CaffeLatte extends Coffee {}
public class Espresso extends Coffee {}

लेकिन अब हमारे पास 8 होंगे:

public class ItalianStyleAmericano extends Coffee {}
public class ItalianStyleCappucino extends Coffee {}
public class ItalianStyleCaffeLatte extends Coffee {}
public class ItalianStyleEspresso extends Coffee {}

public class AmericanStyleAmericano extends Coffee {}
public class AmericanStyleCappucino extends Coffee {}
public class AmericanStyleCaffeLatte extends Coffee {}
public class AmericanStyleEspresso extends Coffee {}

चूंकि हम वर्तमान व्यवसाय मॉडल को बनाए रखना चाहते हैं, इसलिए हम चाहते हैं कि इस orderCoffee(CoffeeType type)पद्धति में यथासंभव कुछ परिवर्तन हों। इस पर एक नज़र मारो:

public Coffee orderCoffee(CoffeeType type) {
    Coffee coffee = coffeeFactory.createCoffee(type);
    coffee.grindCoffee();
    coffee.makeCoffee();
    coffee.pourIntoCup();

    System.out.println("Here's your coffee! Thanks! Come again!");
    return coffee;
}

हमारे पास क्या विकल्प हैं? ठीक है, हम पहले से ही जानते हैं कि फैक्ट्री कैसे लिखनी है, है ना? सबसे सरल बात जो तुरंत दिमाग में आती है वह है दो समान कारखानों को लिखना, और फिर वांछित कार्यान्वयन को हमारे कॉफी शॉप के कंस्ट्रक्टर को पास करना। ऐसा करने से कॉफी शॉप की क्लास नहीं बदलेगी। सबसे पहले, हमें एक नया फ़ैक्टरी वर्ग बनाने की ज़रूरत है, इसे हमारे साधारण फ़ैक्टरी का वारिस बनाएं और फिर createCoffee(CoffeeType type)विधि को ओवरराइड करें। आइए इतालवी शैली की कॉफी और अमेरिकी शैली की कॉफी बनाने के कारखाने लिखें:

public class SimpleItalianCoffeeFactory extends SimpleCoffeeFactory {

    @Override
    public Coffee createCoffee(CoffeeType type) {
        Coffee coffee = null;
        switch (type) {
            case AMERICANO:
                coffee = new ItalianStyleAmericano();
                break;
            case ESPRESSO:
                coffee = new ItalianStyleEspresso();
                break;
            case CAPPUCCINO:
                coffee = new ItalianStyleCappuccino();
                break;
            case CAFFE_LATTE:
                coffee = new ItalianStyleCaffeLatte();
                break;
        }
        return coffee;
    }
}

public class SimpleAmericanCoffeeFactory extends SimpleCoffeeFactory{

    @Override
    public Coffee createCoffee (CoffeeType type) {
        Coffee coffee = null;

        switch (type) {
            case AMERICANO:
                coffee = new AmericanStyleAmericano();
                break;
            case ESPRESSO:
                coffee = new AmericanStyleEspresso();
                break;
            case CAPPUCCINO:
                coffee = new AmericanStyleCappuccino();
                break;
            case CAFFE_LATTE:
                coffee = new AmericanStyleCaffeLatte();
                break;
        }

        return coffee;
    }

}

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

public class Main {
    public static void main(String[] args) {
        /*
            Order an Italian-style cappuccino:
            1. Create a factory for making Italian coffee
            2. Create a new coffee shop, passing the Italian coffee factory to it through the constructor
            3. Order our coffee
         */
        SimpleItalianCoffeeFactory italianCoffeeFactory = new SimpleItalianCoffeeFactory();
        CoffeeShop italianCoffeeShop = new CoffeeShop(italianCoffeeFactory);
        italianCoffeeShop.orderCoffee(CoffeeType.CAPPUCCINO);
        
        
         /*
            Order an American-style cappuccino
            1. Create a factory for making American coffee
            2. Create a new coffee shop, passing the American coffee factory to it through the constructor
            3. Order our coffee
         */
        SimpleAmericanCoffeeFactory americanCoffeeFactory = new SimpleAmericanCoffeeFactory();
        CoffeeShop americanCoffeeShop = new CoffeeShop(americanCoffeeFactory);
        americanCoffeeShop.orderCoffee(CoffeeType.CAPPUCCINO);
    }
}

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

एक साधारण फैक्ट्री से फैक्ट्री विधि तक

यथासंभव कुशलता से कार्य को हल करने के लिए:

1. हम कक्षा createCoffee(CoffeeType type)में विधि लौटाते हैं CoffeeShop।
2. हम इस विधि को सार बना देंगे।
3. वर्ग CoffeeShopही अमूर्त हो जाएगा।
4. कक्षा CoffeeShopमें बाल वर्ग होंगे।

हाँ दोस्त। इतालवी कॉफी शॉप उस वर्ग के वंशज से ज्यादा कुछ नहीं है CoffeeShop, जो createCoffee(CoffeeType type)इतालवी बरिस्ता की सर्वोत्तम परंपराओं के अनुसार पद्धति को लागू करता है। अब, एक समय में एक कदम। चरण 1. Coffeeकक्षा को सार बनाएँ। हमारे पास विभिन्न उत्पादों के दो पूरे परिवार हैं। फिर भी, इतालवी और अमेरिकी कॉफ़ी का एक सामान्य पूर्वज है - Coffeeवर्ग। इसे अमूर्त बनाना उचित होगा:

public abstract class Coffee {
    public void makeCoffee(){
        // Brew the coffee
    }
    public void pourIntoCup(){
        // Pour into a cup
    }
}

चरण 2. CoffeeShopअमूर्त createCoffee(CoffeeType type)विधि से सार बनाएँ

public abstract class CoffeeShop {

    public Coffee orderCoffee(CoffeeType type) {
        Coffee coffee = createCoffee(type);

        coffee.makeCoffee();
        coffee.pourIntoCup();

        System.out.println("Here's your coffee! Thanks! Come again!");
        return coffee;
    }

    protected abstract Coffee createCoffee(CoffeeType type);
}

चरण 3. एक इटालियन कॉफी शॉप बनाएं, जो अमूर्त कॉफी शॉप का वंशज है। हम createCoffee(CoffeeType type)इतालवी प्राप्तियों की बारीकियों को ध्यान में रखते हुए इसमें विधि को लागू करते हैं।

public class ItalianCoffeeShop extends CoffeeShop {

    @Override
    public Coffee createCoffee (CoffeeType type) {
        Coffee coffee = null;
        switch (type) {
            case AMERICANO:
                coffee = new ItalianStyleAmericano();
                break;
            case ESPRESSO:
                coffee = new ItalianStyleEspresso();
                break;
            case CAPPUCCINO:
                coffee = new ItalianStyleCappuccino();
                break;
            case CAFFE_LATTE:
                coffee = new ItalianStyleCaffeLatte();
                break;
        }
        return coffee;
    }
}

चरण 4. हम अमेरिकी शैली की कॉफी शॉप के लिए भी ऐसा ही करते हैं

public class AmericanCoffeeShop extends CoffeeShop {
    @Override
    public Coffee createCoffee(CoffeeType type) {
        Coffee coffee = null;

        switch (type) {
            case AMERICANO:
                coffee = new AmericanStyleAmericano();
                break;
            case ESPRESSO:
                coffee = new AmericanStyleEspresso();
                break;
            case CAPPUCCINO:
                coffee = new AmericanStyleCappuccino();
                break;
            case CAFFE_LATTE:
                coffee = new AmericanStyleCaffeLatte();
                break;
        }

        return coffee;
    }
}

चरण 5. देखें कि अमेरिकी और इतालवी लट्टे कैसे दिखेंगे:

public class Main {
    public static void main(String[] args) {
        CoffeeShop italianCoffeeShop = new ItalianCoffeeShop();
        italianCoffeeShop.orderCoffee(CoffeeType.CAFFE_LATTE);

        CoffeeShop americanCoffeeShop = new AmericanCoffeeShop();
        americanCoffeeShop.orderCoffee(CoffeeType.CAFFE_LATTE);
    }
}

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

कारखाने के तरीकों के पीछे सिद्धांत

अब आइए अधिक विस्तार से विचार करें कि हमें क्या मिला। नीचे दिया गया चित्र परिणामी वर्गों को दिखाता है। हरे ब्लॉक निर्माता वर्ग हैं, और नीले ब्लॉक उत्पाद वर्ग हैं। हम क्या निष्कर्ष निकाल सकते हैं?

1. सभी उत्पाद सार Coffeeवर्ग के कार्यान्वयन हैं।
2. सभी रचनाकार सार CoffeeShopवर्ग के कार्यान्वयन हैं।
3. हम दो समानांतर वर्ग पदानुक्रम देखते हैं:
   • उत्पादों का पदानुक्रम। हम इतालवी वंशजों और अमेरिकी वंशजों को देखते हैं
   • रचनाकारों का पदानुक्रम। हम इतालवी वंशजों और अमेरिकी वंशजों को देखते हैं
4. सुपरक्लास CoffeeShopको इस बारे में कोई जानकारी नहीं है कि कौन सा विशिष्ट उत्पाद ( Coffee) बनाया जाएगा।
5. सुपरक्लास CoffeeShopअपने वंशजों को एक विशिष्ट उत्पाद का निर्माण सौंपता है।
6. वर्ग का प्रत्येक वंशज अपनी विशिष्ट विशेषताओं के अनुसार फ़ैक्टरी पद्धति को CoffeeShopलागू करता है । createCoffee()दूसरे शब्दों में, निर्माता वर्गों के कार्यान्वयन निर्माता वर्ग की बारीकियों के आधार पर विशिष्ट उत्पाद तैयार करते हैं।

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

फ़ैक्टरी विधि की संरचना

ऊपर दिया गया चित्र फ़ैक्टरी विधि पैटर्न की सामान्य संरचना को दर्शाता है। यहाँ और क्या महत्वपूर्ण है?

1. निर्माता वर्ग फ़ैक्टरी विधि को छोड़कर उत्पादों के साथ सहभागिता करने वाली सभी विधियों को लागू करता है।
2. सार पद्धति को वर्ग factoryMethod()के सभी वंशजों द्वारा लागू किया जाना चाहिए ।Creator
3. वर्ग विधि को ConcreteCreatorलागू करता है factoryMethod(), जो सीधे उत्पाद बनाता है।
4. यह वर्ग विशिष्ट उत्पाद बनाने के लिए जिम्मेदार है। यह एकमात्र वर्ग है जिसके पास इन उत्पादों को बनाने की जानकारी है।
5. सभी उत्पादों को एक सामान्य इंटरफ़ेस लागू करना चाहिए, अर्थात वे एक सामान्य उत्पाद वर्ग के वंशज होने चाहिए। यह आवश्यक है ताकि उत्पाद का उपयोग करने वाली कक्षाएं विशिष्ट कार्यान्वयन के बजाय उन पर सार के रूप में काम कर सकें।

गृहकार्य

आज हमने काफी काम किया है और फैक्ट्री मेथड डिजाइन पैटर्न का अध्ययन किया है। यह सामग्री को सुदृढ़ करने का समय है! व्यायाम 1. दूसरी कॉफी शॉप खोलने का काम करें। यह एक अंग्रेजी शैली या स्पेनिश शैली की कॉफी शॉप हो सकती है। या अंतरिक्ष यान-शैली भी। कॉफी को चमकदार बनाने के लिए इसमें फूड कलरिंग मिलाएं, और आपकी कॉफी इस दुनिया से बिल्कुल अलग हो जाएगी! व्यायाम 2। पिछले पाठ में , आपने एक अभ्यास किया था जहाँ आपने एक आभासी सुशी बार या एक आभासी पिज़्ज़ेरिया बनाया था। अब आपका अभ्यास स्थिर नहीं रहना है। आज आपने अपने लाभ के लिए फ़ैक्टरी विधि पैटर्न का उपयोग करना सीखा। यह समय इस ज्ञान का उपयोग करने और अपने स्वयं के व्यवसाय का विस्तार करने का है;)