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

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

• जावा में वंशानुक्रम
• जावा में संदर्भ प्रकारों को कम करना और चौड़ा करना
• विभिन्न वर्गों और वस्तुओं के बीच सहभागिता।

एक कारखाना क्या है?

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

आइए विभिन्न प्रकार की कॉफी बनाते हैं

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

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

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

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

महान। अब हम अपने कॉफी शॉप के लिए कोड लिखते हैं:

public class CoffeeShop {
    
    public Coffee orderCoffee(CoffeeType type) {
        Coffee coffee = null;
        
        switch (type) {
            case AMERICANO:
                coffee = new Americano();
                break;
            case ESPRESSO:
                coffee = new Espresso();
                break;
            case CAPPUCCINO:
                coffee = new Cappucсino();
                break;
            case CAFFE_LATTE:
                coffee = new CaffeLatte();
                break;
        }

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

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

विधि orderCoffeeको दो भागों में विभाजित किया जा सकता है:

1. switchएक बयान में कॉफी के एक विशिष्ट उदाहरण का निर्माण । यह वह जगह है जहां एक कारखाना वह करता है जो वह करता है - स्थितियों के आधार पर एक विशिष्ट प्रकार का निर्माण करता है।
2. तैयारी - यह एक कप में पीसना, पकाना और डालना है।

यहां यह जानना महत्वपूर्ण है कि क्या आपको भविष्य में विधि में परिवर्तन करने की आवश्यकता है:

1. तैयारी में शामिल कदम (पीसना, पकाना और एक कप में डालना) अपरिवर्तित रहेंगे (कम से कम हम इस पर भरोसा कर रहे हैं)।
2. लेकिन कॉफ़ी का वर्गीकरण बदल सकता है। शायद हम मोचा बनाना शुरू करेंगे... फ्राप्पू... मोचाची... जो भी हो, एक नई तरह की कॉफी।

हम पहले से ही काफी आश्वस्त हो सकते हैं कि भविष्य में हमें विधि के switchकथन में परिवर्तन करना होगा। यह भी संभव है कि हमारे कॉफी शॉप में orderCoffeeविधि ही एकमात्र ऐसा स्थान नहीं होगा जहां हम विभिन्न प्रकार की कॉफी बनाएंगे। नतीजतन, कई जगहों पर बदलाव करना होगा। आप शायद पहले से ही समझ गए हैं कि मैं क्या कर रहा हूं। हमें रिफैक्टर करने की जरूरत है। कॉफी बनाने के लिए जिम्मेदार ब्लॉक को दो कारणों से एक अलग वर्ग में ले जाएँ:

1. हम अन्य जगहों पर कॉफी बनाने के तर्क का पुन: उपयोग कर सकते हैं।
2. यदि वर्गीकरण में परिवर्तन होता है, तो हमें हर जगह कॉफी बनाने के लिए कोड संपादित नहीं करना पड़ेगा। हमारे कोड को केवल एक ही स्थान पर बदलने के लिए पर्याप्त होगा।

दूसरे शब्दों में, कारखाना लगाने का समय आ गया है।

अपना पहला कारखाना स्थापित करना

ऐसा करने के लिए, हम एक नया वर्ग बनाएंगे जो केवल कॉफी कक्षाओं के आवश्यक उदाहरण बनाने के लिए जिम्मेदार होगा:

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 Cappucino();
                break;
            case CAFFE_LATTE:
                coffee = new CaffeLatte();
                break;
        }
        
        return coffee;
    }
}

बधाई हो! हमने फ़ैक्टरी डिज़ाइन पैटर्न को उसके सरलतम रूप (लगभग) में लागू किया है। createCoffeeयदि हम विधि को स्थिर बनाते तो यह और भी सरल हो सकता था । लेकिन तब हम दो क्षमताओं को खो देंगे:

1. विधि को इनहेरिट SimpleCoffeeFactoryऔर ओवरराइड करने की क्षमता ।createCoffee
2. हमारी कक्षाओं में आवश्यक कारखाना कार्यान्वयन जोड़ने की क्षमता।

वैसे, कार्यान्वयन की बात करते हुए ... हमें कॉफी शॉप में लौटने और कॉफी बनाने का कारखाना जोड़ने की जरूरत है।

कॉफी शॉप में एक फैक्ट्री जोड़ना

आइए फ़ैक्टरी का उपयोग करके कॉफ़ी शॉप क्लास को फिर से लिखें:

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

उत्कृष्ट। अब हम फ़ैक्टरी डिज़ाइन पैटर्न की सामान्य संरचना का संक्षिप्त विवरण प्रदान करेंगे।

अपना कारखाना खोलने के लिए 5 कदम

चरण 1. आपके कार्यक्रम में कई वंशजों के साथ एक वर्ग है, जैसा कि नीचे चित्र में है: चरण 2. आप enumप्रत्येक बच्चे वर्ग के लिए एक फ़ील्ड बनाते हैं:

    enum CatType {
        LION,
        TIGER,
        FLUFFY
    }

चरण 3. अपना कारखाना बनाएं। बुलाओ CatFactory। यहाँ कोड है:

class CatFactory {}

चरण 4. अपने कारखाने में, एक createCatविधि बनाएँ जो एक CatTypeतर्क लेती है। यहाँ कोड है:

    class CatFactory {
        public Cat createCat(CatType type) {
            
        }
    }

चरण 5। विधि के मुख्य भाग में, एक switchकथन लिखें जो एनुम फ़ील्ड्स की गणना करता है और उस वर्ग का एक उदाहरण बनाता है जो पास किए गए enumमान से मेल खाता है:

class CatFactory {
        public Cat createCat(CatType type) {
            Cat cat = null;
            
            switch (type) {
                case LION:
                    cat =  new Fluffy();
                    break;
                case TIGER:
                    cat = new Tiger();
                    break;
                case FLUFFY:
                    cat =  new Lion();
                    break;
            }
            
            return cat;
        }
    }

अब आप बॉस की तरह फैक्ट्री चला सकते हैं। :)

अभ्यास कैसे करें

पढ़ना अच्छा है, कोड लिखना और भी बेहतर है। यदि आपके नाम में अक्षरों की संख्या सम है, तो अपना स्वयं का वर्चुअल पिज़्ज़ेरिया बनाने का प्रयास करें। यदि आपके नाम में विषम संख्या में अक्षर हैं, तो वर्चुअल सुशी बार बनाने का प्रयास करें। यदि आपके पास कोई नाम नहीं है, तो आप भाग्यशाली हैं। आज आप आराम कर सकते हैं।