ఫ్యాక్టరీ డిజైన్ నమూనా

హాయ్ మిత్రమా! ఈ రోజు మనం డిజైన్ నమూనాలను అధ్యయనం చేస్తూనే ఉంటాము. ఈ పాఠంలో, మేము ఫ్యాక్టరీల గురించి మాట్లాడబోతున్నాము. ఈ నమూనా పరిష్కరించే సమస్యను మేము చర్చిస్తాము మరియు కాఫీ షాప్‌ను తెరవడానికి ఫ్యాక్టరీ మీకు ఎలా సహాయపడుతుందో ఉదాహరణగా చూద్దాం. అదనంగా, ఫ్యాక్టరీని సృష్టించడానికి నేను మీకు 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మేము ఆర్డర్ చేయగల కాఫీ రకాలకు అనుగుణంగా ఉండే 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. పద్ధతి యొక్క బాడీలో, 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;
        }
    }

ఇప్పుడు మీరు బాస్ లాగా ఫ్యాక్టరీని నడపవచ్చు. :)

ఎలా సాధన చేయాలి

చదవడం మంచిది, కోడ్ రాయడం ఇంకా మంచిది. మీ పేరుకు సరి సంఖ్యలో అక్షరాలు ఉంటే, మీ స్వంత వర్చువల్ పిజ్జేరియాని సృష్టించడానికి ప్రయత్నించండి. మీ పేరులో బేసి సంఖ్యలో అక్షరాలు ఉంటే, వర్చువల్ సుషీ బార్‌ని సృష్టించడానికి ప్రయత్నించండి. మీకు పేరు లేకుంటే, మీరు అదృష్టవంతులు. ఈరోజు మీరు విశ్రాంతి తీసుకోవచ్చు.