డిజైన్ నమూనాలు: ఫ్యాక్టరీ పద్ధతి

హాయ్! ఈ రోజు మనం డిజైన్ నమూనాలను అధ్యయనం చేయడం కొనసాగిస్తాము మరియు మేము ఫ్యాక్టరీ పద్ధతి నమూనాను చర్చిస్తాము. ఇది ఏమిటో మరియు ఈ నమూనా ఏ పనులకు అనుకూలంగా ఉందో మీరు కనుగొంటారు. మేము ఈ డిజైన్ నమూనాను ఆచరణలో పరిశీలిస్తాము మరియు దాని నిర్మాణాన్ని అధ్యయనం చేస్తాము. ప్రతిదీ స్పష్టంగా ఉందని నిర్ధారించుకోవడానికి, మీరు ఈ క్రింది అంశాలను అర్థం చేసుకోవాలి:

1. జావాలో వారసత్వం.
2. జావాలో వియుక్త పద్ధతులు మరియు తరగతులు

ఫ్యాక్టరీ పద్ధతి ఏ సమస్యను పరిష్కరిస్తుంది?

అన్ని ఫ్యాక్టరీ డిజైన్ నమూనాలు రెండు రకాల భాగస్వాములను కలిగి ఉంటాయి: సృష్టికర్తలు (ఫ్యాక్టరీలు స్వయంగా) మరియు ఉత్పత్తులు (ఫ్యాక్టరీలు సృష్టించిన వస్తువులు). కింది పరిస్థితిని ఊహించండి: మాకు కోడ్‌జిమ్-బ్రాండెడ్ కార్లను ఉత్పత్తి చేసే ఫ్యాక్టరీ ఉంది. వివిధ రకాల శరీరాలతో కార్ల నమూనాలను ఎలా సృష్టించాలో అతనికి తెలుసు:

• సెడాన్లు
• స్టేషన్ వ్యాగన్లు
• కూపేలు

మా వ్యాపారం ఎంతగా అభివృద్ధి చెందిందంటే, ఒక మంచి రోజు మేము మరో కార్ల తయారీ సంస్థ - OneAutoని కొనుగోలు చేసాము. తెలివైన వ్యాపార యజమానులుగా ఉన్నందున, మేము OneAuto కస్టమర్‌లను కోల్పోకూడదనుకుంటున్నాము, కాబట్టి మేము ఉత్పత్తిని పునర్నిర్మించాల్సిన పనిని ఎదుర్కొంటున్నాము:

• కోడ్‌జిమ్ సెడాన్‌లు
• కోడ్‌జిమ్ స్టేషన్ వ్యాగన్‌లు
• కోడ్‌జిమ్ కూపేలు
• OneAuto సెడాన్లు
• OneAuto స్టేషన్ వ్యాగన్లు
• OneAuto కూపేలు

మీరు చూడగలిగినట్లుగా, ఒక సమూహ ఉత్పత్తులకు బదులుగా, మనకు ఇప్పుడు రెండు ఉన్నాయి మరియు అవి నిర్దిష్ట వివరాలలో విభిన్నంగా ఉంటాయి. మేము ఉత్పత్తుల యొక్క విభిన్న సమూహాలను సృష్టించాల్సిన అవసరం వచ్చినప్పుడు ఫ్యాక్టరీ పద్ధతి రూపకల్పన నమూనా, వీటిలో ప్రతి ఒక్కటి కొన్ని నిర్దిష్ట లక్షణాలను కలిగి ఉంటుంది . మేము ఈ నమూనా యొక్క మార్గదర్శక సూత్రాన్ని ఆచరణలో పరిశీలిస్తాము, మేము మునుపటి పాఠాలలో ఒకదానిలో సృష్టించిన మా కాఫీ షాప్ యొక్క ఉదాహరణను ఉపయోగించి, సాధారణ నుండి కాంప్లెక్స్‌కు క్రమంగా కదులుతాము .

ఫ్యాక్టరీ నమూనా గురించి కొంచెం

మేము ఇంతకు ముందు ఒక చిన్న వర్చువల్ కాఫీ షాప్‌ని నిర్మించామని నేను మీకు గుర్తు చేస్తాను. ఒక సాధారణ ఫ్యాక్టరీ సహాయంతో, మేము వివిధ రకాల కాఫీని ఎలా సృష్టించాలో నేర్చుకున్నాము. ఈ రోజు మనం ఈ ఉదాహరణను మళ్లీ పని చేస్తాము. మా కాఫీ షాప్ దాని సాధారణ ఫ్యాక్టరీతో ఎలా ఉందో గుర్తుచేసుకుందాం. మాకు కాఫీ క్లాస్ ఉంది:

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

ఆర్డర్‌లను సులభంగా ఉంచడానికి మేము ఒక enumని సృష్టించాము:

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

}

ఇప్పుడు మనం కోరుకున్న ఫ్యాక్టరీ అమలును CoffeeShopకి పంపవచ్చు. వివిధ కాఫీ షాపుల నుండి కాఫీని ఆర్డర్ చేసే కోడ్ ఎలా ఉంటుందో చూద్దాం. ఉదాహరణకు, ఇటాలియన్-శైలి మరియు అమెరికన్-శైలి కాపుచినో:

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. చివరి పాఠంలో , మీరు వర్చువల్ సుషీ బార్ లేదా వర్చువల్ పిజ్జేరియాని సృష్టించిన వ్యాయామం చేసారు. ఇప్పుడు మీ వ్యాయామం ఇంకా నిలబడకూడదు. ఈ రోజు మీరు ఫ్యాక్టరీ పద్ధతిని మీ ప్రయోజనం కోసం ఎలా ఉపయోగించాలో నేర్చుకున్నారు. ఈ జ్ఞానాన్ని ఉపయోగించడానికి మరియు మీ స్వంత వ్యాపారాన్ని విస్తరించుకోవడానికి ఇది సమయం;)