హాయ్! ఈ రోజు మనం డిజైన్ నమూనాలను అధ్యయనం చేయడం కొనసాగిస్తాము మరియు మేము ఫ్యాక్టరీ పద్ధతి నమూనాను చర్చిస్తాము. ![డిజైన్ నమూనాలు: ఫ్యాక్టరీ పద్ధతి - 1]()
ఇది ఏమిటో మరియు ఈ నమూనా ఏ పనులకు అనుకూలంగా ఉందో మీరు కనుగొంటారు. మేము ఈ డిజైన్ నమూనాను ఆచరణలో పరిశీలిస్తాము మరియు దాని నిర్మాణాన్ని అధ్యయనం చేస్తాము. ప్రతిదీ స్పష్టంగా ఉందని నిర్ధారించుకోవడానికి, మీరు ఈ క్రింది అంశాలను అర్థం చేసుకోవాలి:
![డిజైన్ నమూనాలు: ఫ్యాక్టరీ పద్ధతి - 2]()
మనం ఏ తీర్మానాలు చేయవచ్చు?
![డిజైన్ నమూనాలు: ఫ్యాక్టరీ పద్ధతి - 3]()
పైన ఉన్న రేఖాచిత్రం ఫ్యాక్టరీ పద్ధతి నమూనా యొక్క సాధారణ నిర్మాణాన్ని చూపుతుంది. ఇక్కడ ఇంకా ముఖ్యమైనది ఏమిటి?
ఇది ఏమిటో మరియు ఈ నమూనా ఏ పనులకు అనుకూలంగా ఉందో మీరు కనుగొంటారు. మేము ఈ డిజైన్ నమూనాను ఆచరణలో పరిశీలిస్తాము మరియు దాని నిర్మాణాన్ని అధ్యయనం చేస్తాము. ప్రతిదీ స్పష్టంగా ఉందని నిర్ధారించుకోవడానికి, మీరు ఈ క్రింది అంశాలను అర్థం చేసుకోవాలి:
- జావాలో వారసత్వం.
- జావాలో వియుక్త పద్ధతులు మరియు తరగతులు
ఫ్యాక్టరీ పద్ధతి ఏ సమస్యను పరిష్కరిస్తుంది?
అన్ని ఫ్యాక్టరీ డిజైన్ నమూనాలు రెండు రకాల భాగస్వాములను కలిగి ఉంటాయి: సృష్టికర్తలు (ఫ్యాక్టరీలు స్వయంగా) మరియు ఉత్పత్తులు (ఫ్యాక్టరీలు సృష్టించిన వస్తువులు). కింది పరిస్థితిని ఊహించండి: మాకు కోడ్‌జిమ్-బ్రాండెడ్ కార్లను ఉత్పత్తి చేసే ఫ్యాక్టరీ ఉంది. వివిధ రకాల శరీరాలతో కార్ల నమూనాలను ఎలా సృష్టించాలో అతనికి తెలుసు:- సెడాన్లు
- స్టేషన్ వ్యాగన్లు
- కూపేలు
- కోడ్‌జిమ్ సెడాన్లు
- కోడ్‌జిమ్ స్టేషన్ వ్యాగన్లు
- కోడ్‌జిమ్ కూపేలు
- 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 {}
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;
}
}
సాధారణ కర్మాగారాన్ని ఆధునీకరించడం
మా కాఫీ షాప్ చాలా బాగా నడుస్తోంది. కాబట్టి మేము విస్తరించడాన్ని పరిశీలిస్తున్నాము. మేము కొన్ని కొత్త స్థానాలను తెరవాలనుకుంటున్నాము. మేము బోల్డ్ మరియు ఎంటర్‌ప్రైజింగ్‌గా ఉన్నాము, కాబట్టి మేము బోరింగ్ కాఫీ షాప్‌లను కొనుగోలు చేయము. ప్రతి దుకాణానికి ప్రత్యేక ట్విస్ట్ ఉండాలని మేము కోరుకుంటున్నాము. దీని ప్రకారం, ప్రారంభించడానికి, మేము రెండు స్థానాలను తెరుస్తాము: ఒక ఇటాలియన్ మరియు ఒక అమెరికన్. ఈ మార్పులు ఇంటీరియర్ డిజైన్‌ను మాత్రమే కాకుండా, అందించే పానీయాలను కూడా ప్రభావితం చేస్తాయి:- ఇటాలియన్ కాఫీ షాప్‌లో, మేము ప్రత్యేకంగా గ్రౌండింగ్ మరియు రోస్టింగ్‌తో ప్రత్యేకంగా ఇటాలియన్ కాఫీ బ్రాండ్‌లను ఉపయోగిస్తాము.
- అమెరికన్ లొకేషన్ పెద్ద భాగాలను కలిగి ఉంటుంది మరియు మేము ప్రతి ఆర్డర్‌తో మార్ష్‌మాల్లోలను అందిస్తాము.
public class Americano extends Coffee {}
public class Cappuccino extends Coffee {}
public class CaffeLatte extends Coffee {}
public class Espresso extends Coffee {}
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కాఫీ మరియు సర్వీసింగ్ ఆర్డర్‌లను సృష్టించే ప్రక్రియలను లింక్ చేయడం ద్వారా తరగతి, అదే సమయంలో వివిధ రకాల కాఫీలను తయారు చేయడానికి తగిన సౌలభ్యాన్ని కొనసాగిస్తుంది. సమాధానం అవును, మనం చేయగలం. దీనిని ఫ్యాక్టరీ మెథడ్ డిజైన్ ప్యాటర్న్ అంటారు.
సాధారణ ఫ్యాక్టరీ నుండి ఫ్యాక్టరీ పద్ధతికి
పనిని సాధ్యమైనంత సమర్థవంతంగా పరిష్కరించడానికి:- మేము
createCoffee(CoffeeType type)పద్ధతిని తరగతికి తిరిగి ఇస్తాముCoffeeShop. - మేము ఈ పద్ధతిని వియుక్తంగా చేస్తాము.
- తరగతి
CoffeeShopకూడా వియుక్తంగా మారుతుంది. - తరగతిలో
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
}
}
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);
}
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;
}
}
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;
}
}
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);
}
}
ఫ్యాక్టరీ పద్ధతుల వెనుక సూత్రం
ఇప్పుడు మనకు లభించిన వాటిని మరింత వివరంగా పరిశీలిద్దాం. దిగువ రేఖాచిత్రం ఫలిత తరగతులను చూపుతుంది. ఆకుపచ్చ బ్లాక్‌లు సృష్టికర్త తరగతులు మరియు నీలం బ్లాక్‌లు ఉత్పత్తి తరగతులు.
మనం ఏ తీర్మానాలు చేయవచ్చు?
- అన్ని ఉత్పత్తులు వియుక్త
Coffeeతరగతి అమలు. - సృష్టికర్తలందరూ అబ్‌స్ట్రాక్ట్
CoffeeShopక్లాస్ యొక్క అమలులే. - మేము రెండు సమాంతర తరగతి సోపానక్రమాలను చూస్తాము:
- ఉత్పత్తుల సోపానక్రమం. మనం ఇటాలియన్ వారసులను మరియు అమెరికన్ వారసులను చూస్తాము
- సృష్టికర్తల సోపానక్రమం. మనం ఇటాలియన్ వారసులను మరియు అమెరికన్ వారసులను చూస్తాము
- సూపర్‌క్లాస్‌లో ఏ నిర్దిష్ట ఉత్పత్తి ( ) సృష్టించబడుతుందనే
CoffeeShopదాని గురించి సమాచారం లేదు .Coffee - సూపర్‌క్లాస్
CoffeeShopనిర్దిష్ట ఉత్పత్తి యొక్క సృష్టిని దాని వారసులకు అప్పగిస్తుంది. - తరగతి యొక్క ప్రతి సంతతి దాని స్వంత ప్రత్యేక లక్షణాలకు అనుగుణంగా ఫ్యాక్టరీ పద్ధతిని
CoffeeShopఅమలు చేస్తుంది .createCoffee()మరో మాటలో చెప్పాలంటే, నిర్మాత తరగతుల అమలులు నిర్మాత తరగతి యొక్క ప్రత్యేకతల ఆధారంగా నిర్దిష్ట ఉత్పత్తులను సిద్ధం చేస్తాయి.
ఫ్యాక్టరీ పద్ధతి యొక్క నిర్మాణం
పైన ఉన్న రేఖాచిత్రం ఫ్యాక్టరీ పద్ధతి నమూనా యొక్క సాధారణ నిర్మాణాన్ని చూపుతుంది. ఇక్కడ ఇంకా ముఖ్యమైనది ఏమిటి?
- క్రియేటర్ క్లాస్ ఫ్యాక్టరీ పద్ధతి మినహా ఉత్పత్తులతో పరస్పర చర్య చేసే అన్ని పద్ధతులను అమలు చేస్తుంది.
- నైరూప్య
factoryMethod()పద్ధతిని తరగతిలోని వారందరూ తప్పనిసరిగా అమలు చేయాలిCreator. - తరగతి పద్ధతిని
ConcreteCreatorఅమలు చేస్తుందిfactoryMethod(), ఇది నేరుగా ఉత్పత్తిని సృష్టిస్తుంది. - నిర్దిష్ట ఉత్పత్తులను రూపొందించడానికి ఈ తరగతి బాధ్యత వహిస్తుంది. ఈ ఉత్పత్తులను రూపొందించడం గురించి సమాచారం ఉన్న ఏకైక తరగతి ఇది.
- అన్ని ఉత్పత్తులు తప్పనిసరిగా ఒక సాధారణ ఇంటర్‌ఫేస్‌ను అమలు చేయాలి, అనగా అవి తప్పనిసరిగా సాధారణ ఉత్పత్తి తరగతికి చెందిన వారసులు అయి ఉండాలి. ఉత్పత్తులను ఉపయోగించే తరగతులు వాటిపై నిర్దిష్ట అమలుల కంటే సంగ్రహణలుగా పనిచేయడానికి ఇది అవసరం.
GO TO FULL VERSION