फॅक्टरी डिझाइन नमुना

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

• जावा मध्ये वारसा
• Java मधील संदर्भ प्रकारांचे संकुचित आणि रुंदीकरण
• विविध वर्ग आणि वस्तूंमधील परस्परसंवाद.

कारखाना म्हणजे काय?

फॅक्टरी डिझाइन पॅटर्न आपल्याला ऑब्जेक्ट्सच्या निर्मितीवर नियंत्रण ठेवू देते. नवीन वस्तू तयार करण्याची प्रक्रिया अत्यंत सोपी नाही, परंतु ती खूप क्लिष्टही नाही. आपल्या सर्वांना माहित आहे की newनवीन ऑब्जेक्ट तयार करण्यासाठी आपल्याला ऑपरेटरची आवश्यकता आहे. कदाचित असे दिसते की येथे नियंत्रण ठेवण्यासाठी काहीही नाही, परंतु ते खरे नाही. समजा आमच्या अर्जाचा एक विशिष्ट वर्ग आहे ज्याचे अनेक वंशज आहेत. जेव्हा विशिष्ट परिस्थितींवर अवलंबून विशिष्ट वर्गाचे उदाहरण तयार करणे आवश्यक असते तेव्हा अडचणी उद्भवू शकतात. फॅक्टरी हा एक डिझाइन नमुना आहे जो विशिष्ट परिस्थितींवर अवलंबून विविध वस्तू तयार करण्याच्या समस्येचे निराकरण करण्यात मदत करतो. अमूर्त संकल्पनेसाठी ते कसे आहे? जेव्हा आपण खालील उदाहरण पाहतो तेव्हा हे अधिक स्पष्ट आणि अधिक स्पष्ट होईल.

चला विविध प्रकारची कॉफी तयार करूया

समजा आम्हाला कॉफी शॉप स्वयंचलित करायचे आहे. विविध प्रकारची कॉफी कशी बनवायची हे आम्हाला आमच्या कार्यक्रमात शिकवावे लागेल. हे करण्यासाठी, आम्ही तयार करणार असलेल्या कॉफीच्या प्रकारांचे प्रतिनिधित्व करण्यासाठी आम्ही एक कॉफी वर्ग आणि काही व्युत्पन्न वर्ग तयार करू: Americano, cappuccino, espresso आणि latte. चला सामान्य कॉफी वर्गाने सुरुवात करूया:

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. तयारी - हे दळणे, brewing, आणि एक कप मध्ये pouring आहे.

तुम्हाला भविष्यात या पद्धतीमध्ये बदल करण्याची आवश्यकता असल्यास हे जाणून घेणे महत्त्वाचे आहे:

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. पद्धतीच्या मुख्य भागामध्ये, switchenum फील्डची गणना करणारे विधान लिहा आणि पास केलेल्या मूल्याशी संबंधित वर्गाचे उदाहरण तयार करा 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;
        }
    }

आता तुम्ही बॉसप्रमाणे कारखाना चालवू शकता. :)

सराव कसा करावा

वाचन चांगले आहे, कोड लिहिणे अधिक चांगले आहे. तुमच्या नावावर सम संख्या असल्यास, तुमचा स्वतःचा व्हर्च्युअल पिझ्झरिया तयार करण्याचा प्रयत्न करा. तुमच्या नावावर विचित्र अक्षरे असल्यास, व्हर्च्युअल सुशी बार तयार करण्याचा प्रयत्न करा. जर तुमचे नाव नसेल तर तुम्ही नशीबवान आहात. आज तुम्ही आराम करू शकता.