हाय! आज आपण डिझाइन पॅटर्नचा अभ्यास करत राहू आणि फॅक्टरी पद्धतीच्या पॅटर्नवर चर्चा करू. हे काय आहे आणि कोणत्या कार्यांसाठी हा नमुना योग्य आहे हे तुम्हाला कळेल. आम्ही या डिझाइन पॅटर्नचा सराव मध्ये विचार करू आणि त्याच्या संरचनेचा अभ्यास करू. सर्वकाही स्पष्ट आहे याची खात्री करण्यासाठी, तुम्हाला खालील विषय समजून घेणे आवश्यक आहे:
- जावा मध्ये वारसा.
- जावा मधील अमूर्त पद्धती आणि वर्ग
कारखाना पद्धत कोणती समस्या सोडवते?
सर्व फॅक्टरी डिझाइन पॅटर्नमध्ये दोन प्रकारचे सहभागी असतात: निर्माते (स्वतः कारखाने) आणि उत्पादने (कारखान्याद्वारे तयार केलेल्या वस्तू). खालील परिस्थितीची कल्पना करा: आमच्याकडे कोडजिम-ब्रँडेड कार तयार करणारा कारखाना आहे. विविध प्रकारच्या शरीरासह कारचे मॉडेल कसे तयार करावे हे माहित आहे:- सेडान
- स्टेशन वॅगन्स
- कूप
- कोडजिम सेडान
- कोडजिम स्टेशन वॅगन्स
- CodeGym coupes
- OneAuto sedans
- वनऑटो स्टेशन वॅगन
- OneAuto coupes
फॅक्टरी पॅटर्नबद्दल थोडेसे
मी तुम्हाला आठवण करून देतो की आम्ही पूर्वी एक लहान आभासी कॉफी शॉप बांधले होते. एका साध्या कारखान्याच्या मदतीने आम्ही विविध प्रकारची कॉफी कशी तयार करायची हे शिकलो. आज आपण हे उदाहरण पुन्हा काम करू. आमची कॉफी शॉप त्याच्या साध्या फॅक्टरीसह कसे दिसत होते ते आठवूया. आमचा कॉफी वर्ग होता:
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 {}
पण आता आपल्याकडे 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;
}
}
आता आम्ही कॉफीशॉपला इच्छित फॅक्टरी अंमलबजावणी पास करू शकतो. वेगवेगळ्या कॉफी शॉप्समधून कॉफी ऑर्डर करण्याचा कोड कसा असेल ते पाहूया. उदाहरणार्थ, इटालियन-शैली आणि अमेरिकन-शैलीतील कॅपुचिनो:
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
}
}
पायरी 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);
}
}
अभिनंदन. आम्ही आमच्या कॉफी शॉपचे उदाहरण म्हणून फॅक्टरी पद्धत डिझाइन पॅटर्न नुकतेच लागू केले.
फॅक्टरी पद्धतींमागील तत्त्व
आता आपल्याला काय मिळाले याचा अधिक तपशीलवार विचार करूया. खालील आकृती परिणामी वर्ग दर्शविते. हिरवे ब्लॉक हे निर्माते वर्ग आहेत आणि निळे ब्लॉक हे उत्पादन वर्ग आहेत. आपण कोणते निष्कर्ष काढू शकतो?- सर्व उत्पादने अमूर्त
Coffee
वर्गाची अंमलबजावणी आहेत. - सर्व निर्माते अमूर्त
CoffeeShop
वर्गाची अंमलबजावणी करतात. - आम्ही दोन समांतर वर्ग पदानुक्रम पाहतो:
- उत्पादनांची पदानुक्रम. आम्ही इटालियन वंशज आणि अमेरिकन वंशज पाहतो
- निर्मात्यांची पदानुक्रम. आम्ही इटालियन वंशज आणि अमेरिकन वंशज पाहतो
- कोणते विशिष्ट उत्पादन ( ) तयार केले जाईल याबद्दल सुपरक्लासमध्ये
CoffeeShop
कोणतीही माहिती नाही .Coffee
- सुपरक्लास
CoffeeShop
विशिष्ट उत्पादनाची निर्मिती त्याच्या वंशजांना सोपवतो. - वर्गातील प्रत्येक वंशज त्याच्या स्वतःच्या विशिष्ट वैशिष्ट्यांनुसार फॅक्टरी पद्धत
CoffeeShop
लागू करतोcreateCoffee()
. दुसऱ्या शब्दांत, उत्पादक वर्गांची अंमलबजावणी उत्पादक वर्गाच्या वैशिष्ट्यांवर आधारित विशिष्ट उत्पादने तयार करतात.
फॅक्टरी पद्धतीची रचना
वरील आकृती फॅक्टरी पद्धतीच्या पॅटर्नची सामान्य रचना दर्शवते. येथे आणखी काय महत्वाचे आहे?- क्रिएटर वर्ग फॅक्टरी पद्धत वगळता उत्पादनांशी संवाद साधणाऱ्या सर्व पद्धती लागू करतो.
- अमूर्त
factoryMethod()
पद्धत वर्गाच्या सर्व वंशजांनी अंमलात आणली पाहिजेCreator
. - वर्ग पद्धत
ConcreteCreator
लागू करतोfactoryMethod()
, जी थेट उत्पादन तयार करते. - हा वर्ग विशिष्ट उत्पादने तयार करण्यासाठी जबाबदार आहे. ही उत्पादने तयार करण्याबाबत माहिती असलेला हा एकमेव वर्ग आहे.
- सर्व उत्पादनांनी एक सामान्य इंटरफेस लागू करणे आवश्यक आहे, म्हणजे ते सामान्य उत्पादन वर्गाचे वंशज असले पाहिजेत. हे आवश्यक आहे जेणेकरुन उत्पादने वापरणारे वर्ग त्यावर विशिष्ट अंमलबजावणी करण्याऐवजी अमूर्त म्हणून कार्य करू शकतील.
GO TO FULL VERSION