दिलचस्प पोस्ट
सभी शाखाओं के लिए जानकारी, आगे और पीछे देखें, जिसमें रीमोट्स शामिल हैं शामिल हैं, शामिल हैं, की आवश्यकता है या आवश्यकता है? पायथन में बड़ी फाइल पढ़ने के लिए आलसी विधि? बूटस्ट्रैप 3: पृष्ठ ताज़ा पर चयनित टैब रखें Angular2 में ngShow और ngHide के बराबर क्या है? MVCBuildViews सही ढंग से काम नहीं कर रहा है निर्माण का निर्माण क्या होता है? आकार ऑपरेटर क्यों माना जाता है? linq केस बयान Android पर HTTP के लिए प्रमाणपत्र स्वीकार करना JQuery में एक div तत्व बनाना किसी विंडो के बिना एक एप्लिकेशन बनाएं सीमके: सेटअप स्रोत, लाइब्रेरी और सीएमकेलिस्ट्स टैक्स्ट निर्भरता कैसे करें? जब अस्थिर खोजशब्द को सी # में इस्तेमाल किया जाना चाहिए? गतिशील रूप से जोड़ा गया ड्रॉपडाउनलाइस्टर्स चयनित फ़ायरिंग नहीं कर रहे हैंअनुक्रमित ईवेंट

रणनीति पैटर्न का असली दुनिया का उदाहरण

मैं ओसीपी प्रिंसिपल के बारे में पढ़ रहा हूं और इसे पूरा करने के लिए रणनीति का उपयोग कैसे करें।

मैं कोशिश कर रहा हूं और कुछ लोगों को इसकी व्याख्या करता हूं, लेकिन एकमात्र उदाहरण मैं सोच सकता हूँ कि किस स्थिति के आधार पर "ऑर्डर" है, के आधार पर अलग-अलग मान्यता वर्गों का उपयोग कर रहा है।

मैंने कुछ लेख ऑनलाइन पढ़ा है, लेकिन ये आम तौर पर रणनीति का उपयोग करने के लिए एक वास्तविक तरह का वर्णन नहीं करते हैं, जैसे रिपोर्ट्स / बिल / सत्यापन आदि उत्पन्न करना …

क्या कोई वास्तविक दुनिया उदाहरण हैं जहां आपको लगता है कि एक रणनीति पैटर्न आम है?

वेब के समाधान से एकत्रित समाधान "रणनीति पैटर्न का असली दुनिया का उदाहरण"

इस बारे में क्या:

आपको एक फाइल को एन्क्रिप्ट करना होगा

छोटी फाइलों के लिए, आप "मेमोरी" रणनीति का उपयोग कर सकते हैं, जहां पूरी फाइल पढ़ी जाती है और मेमोरी में रखी जाती है (हम फाइल <1 जीबी के लिए कहते हैं)

बड़ी फ़ाइलों के लिए, आप दूसरी रणनीति का उपयोग कर सकते हैं, जहां फ़ाइल के कुछ हिस्सों को स्मृति में पढ़ा जाता है और आंशिक एन्क्रिप्ट किए गए परिणाम tmp फ़ाइलों में संग्रहीत होते हैं।

ये एक ही कार्य के लिए दो अलग-अलग रणनीति हो सकती है

क्लाइंट कोड उसी पर दिखेगा:

File file = getFile(); Cipher c = CipherFactory.getCipher( file.size() ); c.performAction(); // implementations: interface Cipher { public void performAction(); } class InMemoryCipherStrategy implements Cipher { public void performAction() { // load in byte[] .... } } class SwaptToDiskCipher implements Cipher { public void performAction() { // swapt partial results to file. } } 

  Cipher c = CipherFactory.getCipher( file.size() ); 

साइफर के लिए सही रणनीति उदाहरण लौटाएंगे

आशा है कि ये आपकी मदद करेगा।

(मुझे यह भी पता नहीं है कि साइफर सही शब्द है: पी)

दोबारा, एक पुरानी पोस्ट है लेकिन अभी भी खोजों पर मुड़ता है इसलिए मैं दो और उदाहरण जोड़ूंगा (कोड सी # में है) मैं पूरी तरह से रणनीति पैटर्न से प्यार करता हूं क्योंकि परियोजना प्रबंधकों का कहना है कि "हम आवेदन करना चाहते हैं, लेकिन अभी तक स्पष्ट नहीं है और यह निकट भविष्य में बदल सकता है"। मुझे पूरा यकीन है कि इस वीडियो में स्टारकाफ्ट का उपयोग एक उदाहरण के रूप में रणनीति पैटर्न के बारे में बहुत कुछ है, जो सब कुछ बताता है: http://www.youtube.com/watch?v=MOEsKHqLiBM

इस श्रेणी में आने वाली सामग्री:

  • छंटाई (हम इन नंबरों को सॉर्ट करना चाहते हैं, लेकिन हम नहीं जानते कि हम ईंट्सोर्ट, बुलबुले या कुछ अन्य सॉर्टिंग का उपयोग कर रहे हैं)

  • मान्यकरण (हमें "कुछ नियम" के अनुसार आइटम की जांच करने की आवश्यकता है, लेकिन यह अभी तक स्पष्ट नहीं है कि यह नियम क्या होगा, और हम नए लोगों के बारे में सोच सकते हैं।)

  • खेल (हम खिलाड़ी चाहते हैं कि वह चलने पर चलें या चलें, लेकिन भविष्य में शायद वह तैरना, फ्लाई, टेलीपोर्ट, बर्गो भूमिगत, इत्यादि में सक्षम होना चाहिए)

  • जानकारी संग्रहीत करना (हम चाहते हैं कि वह डाटा को डाटाबेस में संग्रहीत करे, लेकिन बाद में उसे फाइल सहेजने या वेबकॉल बनाने में सक्षम होना चाहिए)

  • आउटपुटिंग (हमें आउटपुट एक्स को एक सादा स्ट्रिंग के रूप में होना चाहिए, लेकिन बाद में एक सीएसवी, एक्सएमएल, जेएसन, आदि हो सकता है)


उदाहरण

मेरे पास एक ऐसा प्रोजेक्ट है जहां उपयोगकर्ता एक डेटाबेस में लोगों को उत्पाद प्रदान कर सकते हैं। किसी व्यक्ति को किसी उत्पाद का यह काम एक ऐसी स्थिति है जो "स्वीकृत" या "अस्वीकृत" है, जो कि कुछ व्यवसायिकों पर निर्भर है। (उदाहरण के लिए, एक उपयोगकर्ता एक निश्चित उम्र के साथ किसी उत्पाद को निर्दिष्ट करता है, तो इसकी स्थिति घटती जानी चाहिए, यदि आइटम में दो फ़ील्ड के बीच का अंतर 50 से बड़ा होता है, तो इसकी स्थिति घटती है, आदि)

अब, विकास के समय में ये व्यवसायिक अभी तक पूरी तरह से स्पष्ट नहीं हैं, और नए नियम किसी भी समय ऊपर आ सकते हैं। स्ट्रैगेटि-पैटर्न की शक्ति यह है कि मैंने एक नियम एजट बनाया है, जिसे आईआरलॉग की सूची दी गई है।

 public interface IRule { bool IsApproved(Assignment assignment); } 

किसी व्यक्ति को किसी उत्पाद को निर्दिष्ट करने के समय, मैं एक नियम एजट तैयार करता हूं, इसे नियमों की सूची दें (जो सभी आईआरली को लागू करते हैं), और एक असाइनमेंट को मान्य करने के लिए कहें। यह सभी के नियमों के माध्यम से चलेंगे (जो कि वे सभी एक ही इंटरफ़ेस को लागू करते हैं, सभी में IsApproved विधि है) और झूठी वापसी अगर उनमें से कोई भी झूठी वापसी करता है।

उदाहरण के तौर पर जब प्रबंधक अचानक आ जाता है और कहता है, हमें महिलाओं के सभी कामों को अस्वीकार करने की आवश्यकता है, या आखिरी नाम "जॉन्सन" या जो कुछ भी है उन सभी कार्यों को अस्वीकार करना होगा … आप इस तरह नई कक्षाएं बनाते हैं:

 public LastNameRule : IRule { public bool IsApproved(Assignment assignment) //Interface method { if (assignment.Person.Lastname == "Johnsson") { return false; } return true; } } public GenderRule : IRule { public bool IsApproved(Assignment assignment) //Interface method { if (assignment.Person.Gender== Gender.Female) { return false; } return true; } } 

आप देखते हैं कि आप को जोड़ने या हटाने-बयान या कोड नहीं है, सिर्फ एक नया नियम-वर्ग बनाने के लिए जो IRUle इंटरफ़ेस लागू करता है और आवश्यकतानुसार उन पर स्विच कर देता है।


एक अन्य महान उदाहरण ( http://www.asp.net/mvc/pluralsight पर स्कॉट एलेन की वीडियो धारावाहिक द्वारा वह आवेदन के यूनिट-टेस्ट भाग में रणनीति के तरीके का उपयोग करता है)

वह एक वेबसाइट बनाता है जिसमें एक पृष्ठ है जो लोकप्रियता के आधार पर आइटम प्रदर्शित करता है। हालांकि "लोकप्रिय" कई चीजें (अधिकांश दृश्य, अधिकांश ग्राहक, निर्माण तिथि, सबसे अधिक गतिविधि, कम से कम टिप्पणियां, जो भी हो) हो सकती हैं, और अगर प्रबंधन को अभी तक पता नहीं है कि कैसे ऑर्डर करना है और अलग-अलग के साथ प्रयोग करना चाहेगा बाद की तारीख में ऑर्डरिंग आप एक ऑर्डर विधि के साथ एक इंटरफ़ेस (IOrderAlgorithm या somethng) बनाते हैं, और एक ऑर्डरर-ऑब्जेक्ट को IOrderAlgorithm इंटरफ़ेस के एक ठोस कार्यान्वयन के आदेश देने दें। आप एक "टिप्पणी ऑर्डरर", "गतिविधि ऑर्डरर", आदि कर सकते हैं … और जब नई ज़रूरतें पूरी हों तो इन पर स्विच करें।

मैं कई साधारण उदाहरणों के बारे में सोच सकता हूं:

  • एक सूची छंटनी रणनीति यह तय करती है कि सूची में दो मदों में से कौन सा "प्रथम" है
  • आपके पास एक ऐसा एप्लिकेशन हो सकता है जहां सॉर्टिंग एल्गोरिदम खुद (QuickSort, HeapSort, आदि) रनटाइम पर चुना जा सकता है
  • Log4Net और Log4j में अपेंडर्स , लेआउट, और फ़िल्टर
  • UI टूलकिट में लेआउट प्रबंधक
  • आधार – सामग्री संकोचन। आपके पास एक ICompressor इंटरफ़ेस हो सकता है जिसका एकमात्र तरीका ऐसा कुछ दिखता है:

    बाइट [] संक्षिप्त (बाइट [] इनपुट);

    आपकी कंक्रीट संपीड़न कक्षाएं, रनलेेंडा कॉम्प्रेशन, डिफ्लेट कॉम्प्रेशन आदि जैसी चीजें हो सकती हैं।

मेरे पास एक ऐसा एप्लिकेशन है जो हमारे एन्टरप्राइज़ निर्देशिका के विरुद्ध प्रत्येक दिन उपयोगकर्ता आधार को सिंक्रनाइज़ करता है। उपयोगकर्ता विश्वविद्यालय में अपनी स्थिति के आधार पर पात्र या योग्य नहीं हैं। प्रत्येक दिन प्रावधानीकरण कार्यक्रम के माध्यम से जाता है और यह सुनिश्चित करता है कि जो लोग योग्य होना चाहिए वे आवेदन में प्रावधान किए गए हैं और जो लोग बिना प्रावधान (वास्तव में एक सुशोभित अवसाद एल्गोरिथ्म के अनुसार हैं, लेकिन यह बिंदु के बगल में है)। शनिवार को मैं एक और पूरी तरह से अद्यतन करता हूं जो प्रत्येक उपयोगकर्ता के कुछ गुणों को सिंक्रनाइज़ करता है और साथ ही यह सुनिश्चित करने के लिए कि उनके पास उचित पात्रता है। महीने के अंत में मैं उस महीने के उपयोग के आधार पर कुछ बिल वापस प्रसंस्करण करता हूं।

मैं इस तुल्यकालन को करने के लिए एक रचनात्मक रणनीति पद्धति का उपयोग करता हूं। मुख्य कार्यक्रम मूल रूप से सप्ताह के दिन (सिंक परिवर्तन केवल / सभी सिंक) के आधार पर एक मास्टर रणनीति चुनता है और शैक्षणिक कैलेंडर के सापेक्ष के समय। अगर बिलिंग चक्र समाप्त हो रहा है, तो यह एक बिलिंग रणनीति के साथ भी तैयार करता है यह तब एक मानक इंटरफ़ेस के माध्यम से चुना गया रणनीति चलाता है।

मुझे नहीं पता कि यह कैसे आम है, लेकिन मुझे लगा जैसे यह रणनीति पैटर्न के लिए एकदम सही फिट था

रणनीति पद्धति का एक सामान्य उपयोग कस्टम सॉर्टिंग रणनीतियों (उच्च-क्रम फ़ंक्शन के बिना भाषाओं में) को परिभाषित करना है, उदाहरण के लिए जावा में लंबाई द्वारा तार की एक सूची को सॉर्ट करने के लिए, एक अनाम आंतरिक कक्षा (रणनीति इंटरफ़ेस का कार्यान्वयन) पारित करना:

 List<String> names = Arrays.asList("Anne", "Joe", "Harry"); Collections.sort(names, new Comparator<String>() { public int compare(String o1, String o2) { return o1.length() - o2.length(); } }); Assert.assertEquals(Arrays.asList("Joe", "Anne", "Harry"), names); 

इसी तरह, रणनीतियों को ऑब्जेक्ट डाटाबेस के साथ मूल प्रश्नों के लिए इस्तेमाल किया जा सकता है, जैसे डीबी 4 ओ में:

 List<Document> set = db.query(new Predicate<Document>() { public boolean match(Document candidate) { return candidate.getSource().contains(source); } }); 

मुझे पता है यह एक पुराना सवाल है, लेकिन मुझे लगता है कि मैंने एक और रोचक उदाहरण दिया है जिसे मैंने हाल ही में लागू किया था।

दस्तावेज़ वितरण प्रणाली में उपयोग किए जा रहे रणनीति के पैटर्न का यह एक बहुत ही व्यावहारिक उदाहरण है

मेरे पास एक पीडीएफ डिलीवरी सिस्टम था जिसमें एक दस्तावेज प्राप्त हुआ जिसमें कई सारे दस्तावेज और कुछ मेटाडेटा शामिल थे। मेटाडेटा के आधार पर, यह निर्णय लिया कि दस्तावेज़ को कहां रखा जाए; कहते हैं, डेटा के आधार पर, मैं A , B या C स्टोरेज सिस्टम में दस्तावेज को स्टोर कर सकता हूं, या तीनों का मिश्रण

अलग-अलग ग्राहकों ने इस प्रणाली का इस्तेमाल किया, और त्रुटियों के मामले में उनके पास भिन्न रोलबैक / त्रुटि से निपटने की आवश्यकताएं थीं: एक डिलीवरी सिस्टम को पहली त्रुटि पर रोकना चाहता था, जो पहले से ही अपने भंडार में दिए गए सभी दस्तावेज़ों को छोड़ते हैं, लेकिन प्रक्रिया को रोकते हैं और कुछ भी नहीं देते हैं ; C में भंडारण करते समय किसी और को B से रोलबैक करना था, लेकिन A को पहले से ही जो कुछ भी दिया गया था उसे छोड़ दें। यह कल्पना करना आसान है कि तीसरे या चौथे को अलग-अलग ज़रूरतें भी होंगी

समस्या को हल करने के लिए, मैंने एक बुनियादी डिलीवरी क्लास बनाया है जिसमें डिलीवरी लॉजिक है, साथ ही सभी स्टोरेज के सामान वापस रोल करने के लिए तरीके त्रुटियों के मामले में उन विधियों को सीधे डिलीवरी सिस्टम द्वारा सीधे नहीं बुलाया जाता है इसके बजाय, क्लास "रोलबैक / त्रुटि हैंडलिंग स्ट्रैटेजी" वर्ग (सिस्टम का उपयोग कर ग्राहक के आधार पर) प्राप्त करने के लिए निर्भरता इंजेक्शन का उपयोग करता है, जिसे त्रुटियों के मामले में कहा जाता है, जो बदले में रोलबैक विधियों को कॉल करता है यदि यह उस रणनीति के लिए उपयुक्त है

डिलीवरी क्लास स्वयं रणनीति वर्ग के बारे में बताता है (कौन से दस्तावेज क्या भंडार, और क्या विफलता हुआ) पर दिए गए, और जब भी कोई त्रुटि हुई, तो यह रणनीति जारी रखेगी कि क्या जारी है या नहीं। यदि रणनीति कहती है कि "इसे रोकें", तो क्लास रणनीति की "साफ-सफाई" पद्धति को कहता है, जो पहले से रिपोर्ट करने वाली रिपोर्ट का उपयोग करता है जो तय करने के लिए कि रोलबैक विधियां डिलीवरी क्लास से कैसे कॉल करती हैं या बस कुछ भी नहीं करती हैं।

 rollbackStrategy.reportSuccessA(...); rollbackStrategy.reportFailureB(...); if (rollbackStrategy.mustAbort()) { rollbackStrategy.rollback(); // rollback whatever is needed based on reports return false; } 

इसलिए अब मेरे पास दो अलग रणनीतियों हैं: एक QuitterStrategy (जो पहली त्रुटि से निकलती है और कुछ भी साफ नहीं करता है) और दूसरा एक MaximizeDeliveryToAStrategy QuitterStrategy (जो कि जितना संभव हो उतना संभव नहीं है जितना संभव प्रक्रिया को रद्द करना और कभी भी रोलबैक सामान को स्टोरेज में नहीं दिया जाता है A , लेकिन C लिए डिलीवरी विफल होने पर B सामान रोलबैक होते हैं)।

मेरी समझ से, यह रणनीति पैटर्न का एक उदाहरण है। यदि आप (हाँ, आप पढ़ रहे हैं) मुझे लगता है कि मैं गलत हूँ, कृपया नीचे टिप्पणी करें और मुझे बताएं मैं इस बात के बारे में उत्सुक हूं कि क्या रणनीति के पैटर्न का "शुद्ध" उपयोग होगा, और मेरे कार्यान्वयन के किन पहलुओं की परिभाषा का उल्लंघन है मुझे लगता है कि यह थोड़ा अजीब लगता है क्योंकि रणनीति इंटरफ़ेस थोड़ा मोटा है मैंने देखा है कि सभी उदाहरणों में अभी तक केवल एक ही तरीका का उपयोग किया गया है, लेकिन मुझे अभी भी लगता है कि यह एक एल्गोरिदम (यदि व्यावसायिक तर्क का एक टुकड़ा एक एल्गोरिथ्म माना जा सकता है, जिसे मुझे लगता है कि) करता है।

चूंकि वितरण निष्पादन के दौरान कार्यवाही के बारे में भी सूचित किया जाता है, इसलिए इसे एक प्रेक्षक भी माना जा सकता है, लेकिन यह एक और कहानी है

थोड़ा शोध करने से, ऐसा लगता है कि यह एक "समग्र पैटर्न" (जैसे एमवीसी, एक पैटर्न जो एक विशेष तरीके से कई डिज़ाइन पैटर्न का उपयोग करता है) सलाहकार कहा जाता है यह एक सलाहकार है कि डिलीवरी जारी रहती है या नहीं, लेकिन यह एक सक्रिय त्रुटि हैंडल भी है क्योंकि यह पूछे जाने पर सामान वापस रोल कर सकता है

वैसे भी, यह एक बहुत ही जटिल उदाहरण है जो आपकी उस भावना को बना सकता है कि रणनीति के पैटर्न का उपयोग बहुत आसान / मूर्खतापूर्ण है अन्य नमूनों के साथ उपयोग करते समय यह वास्तव में जटिल और अधिक लागू हो सकता है

मुख्य नोट:

  1. रणनीति व्यवहार डिजाइन पैटर्न है इसका इस्तेमाल एल्गोरिदम के परिवार के बीच स्विच करने के लिए किया जाता है।

  2. इस पैटर्न में एक सार रणनीति इंटरफ़ेस और उस इंटरफ़ेस के कई ठोस रणनीति लागूकरण ( एल्गोरिदम ) शामिल हैं।

  3. यह एप्लिकेशन केवल रणनीति अंतरफलक का उपयोग करता है कुछ कॉन्फ़िगरेशन पैरामीटर के आधार पर, ठोस रणनीति को इंटरफ़ेस पर टैग किया जाएगा।

विकिपीडिया से यूएमएल आरेख

यहां छवि विवरण दर्ज करें

एक वास्तविक शब्द उदाहरण: एयरलाइंस कुछ महीनों (जुलाई-दिसंबर) के दौरान छूट दे रही है । आपके पास एक किराया मॉड्यूल हो सकता है, जो महीने के नंबर के आधार पर मूल्य निर्धारण विकल्प तय करता है।

एक सरल उदाहरण पर एक नज़र डालें इस उदाहरण को ऑन-लाइन रिटेलिंग अनुप्रयोगों तक बढ़ाया जा सकता है, जो शॉपिंग कार्ट आइटम को विशेष दिन / ख़ुफ़ घंटे पर आसानी से छूट देता है।

 import java.util.*; /* Interface for Strategy */ interface OfferStrategy { public String getName(); public double getDiscountPercentage(); } /* Concrete implementation of base Strategy */ class NoDiscountStrategy implements OfferStrategy{ public String getName(){ return this.getClass().getName(); } public double getDiscountPercentage(){ return 0; } } /* Concrete implementation of base Strategy */ class QuarterDiscountStrategy implements OfferStrategy{ public String getName(){ return this.getClass().getName(); } public double getDiscountPercentage(){ return 0.25; } } /* Context is optional. But if it is present, it acts as single point of contact for client. Multiple uses of Context 1. It can populate data to execute an operation of strategy 2. It can take independent decision on Strategy creation. 3. In absence of Context, client should be aware of concrete strategies. Context acts a wrapper and hides internals 4. Code re-factoring will become easy */ class StrategyContext { double price; // price for some item or air ticket etc. Map<String,OfferStrategy> strategyContext = new HashMap<String,OfferStrategy>(); StrategyContext(double price){ this.price= price; strategyContext.put(NoDiscountStrategy.class.getName(),new NoDiscountStrategy()); strategyContext.put(QuarterDiscountStrategy.class.getName(),new QuarterDiscountStrategy()); } public void applyStrategy(OfferStrategy strategy){ /* Currently applyStrategy has simple implementation. You can use Context for populating some more information, which is required to call a particular operation */ System.out.println("Price before offer :"+price); double finalPrice = price - (price*strategy.getDiscountPercentage()); System.out.println("Price after offer:"+finalPrice); } public OfferStrategy getStrategy(int monthNo){ /* In absence of this Context method, client has to import relevant concrete Strategies everywhere. Context acts as single point of contact for the Client to get relevant Strategy */ if ( monthNo < 6 ) { return strategyContext.get(NoDiscountStrategy.class.getName()); }else{ return strategyContext.get(QuarterDiscountStrategy.class.getName()); } } } public class StrategyDemo{ public static void main(String args[]){ StrategyContext context = new StrategyContext(100); System.out.println("Enter month number between 1 and 12"); int month = Integer.parseInt(args[0]); System.out.println("Month ="+month); OfferStrategy strategy = context.getStrategy(month); context.applyStrategy(strategy); } } 

उत्पादन:

 Enter month number between 1 and 12 Month =1 Price before offer :100.0 Price after offer:100.0 Enter month number between 1 and 12 Month =7 Price before offer :100.0 Price after offer:75.0 

उपयोगी लेख:

डोजोन द्वारा रणनीति पैटर्न

स्रोत निर्माण द्वारा रणनीति पैटर्न

रणनीति के पैटर्न का एक अच्छा उदाहरण एक खेल में होगा जहां हमारे पास अलग-अलग वर्ण हो सकते हैं और प्रत्येक चरित्र पर हमला करने के लिए कई हथियार हो सकते हैं, लेकिन एक समय में केवल एक हथियार का उपयोग किया जा सकता है इसलिए हमारे पास चरित्र के रूप में संदर्भ है, उदाहरण के लिए राजा, कमांडर, नाइट, सैनिक और हथियार एक ऐसी रणनीति के रूप में जहां हमले () विधि / एल्गोरिदम हो सकता है जो हथियारों पर निर्भर करता है। इसलिए यदि ठोस हथियार वर्ग तलवार, कुल्हाड़ी, क्रॉसबो, बो एंड्रॉ आदि थे। वे सभी हमले () विधि को लागू करेंगे। मुझे यकीन है कि आगे की स्पष्टीकरण की आवश्यकता नहीं है।

रणनीति पैटर्न सबसे अधिक विशिष्ट रूप से इस्तेमाल किया जाता है विशेषकर मान्यताओं और सॉर्टिंग एल्गोरिदम के लिए।

मुझे एक साधारण व्यावहारिक उदाहरण के साथ समझाइए

 enum Speed { SLOW, MEDIUM, FAST; } class Sorter { public void sort(int[] input, Speed speed) { SortStrategy strategy = null; switch (speed) { case SLOW: strategy = new SlowBubbleSortStrategy(); break; case MEDIUM: strategy = new MediumInsertationSortStrategy(); break; case FAST: strategy = new FastQuickSortStrategy(); break; default: strategy = new MediumInsertationSortStrategy(); } strategy.sort(input); } } interface SortStrategy { public void sort(int[] input); } class SlowBubbleSortStrategy implements SortStrategy { public void sort(int[] input) { for (int i = 0; i < input.length; i++) { for (int j = i + 1; j < input.length; j++) { if (input[i] > input[j]) { int tmp = input[i]; input[i] = input[j]; input[j] = tmp; } } } System.out.println("Slow sorting is done and the result is :"); for (int i : input) { System.out.print(i + ","); } } } class MediumInsertationSortStrategy implements SortStrategy { public void sort(int[] input) { for (int i = 0; i < input.length - 1; i++) { int k = i + 1; int nxtVal = input[k]; while (input[k - 1] > nxtVal) { input[k] = input[k - 1]; k--; if (k == 0) break; } input[k] = nxtVal; } System.out.println("Medium sorting is done and the result is :"); for (int i : input) { System.out.print(i + ","); } } } class FastQuickSortStrategy implements SortStrategy { public void sort(int[] input) { sort(input, 0, input.length-1); System.out.println("Fast sorting is done and the result is :"); for (int i : input) { System.out.print(i + ","); } } private void sort(int[] input, int startIndx, int endIndx) { int endIndexOrig = endIndx; int startIndexOrig = startIndx; if( startIndx >= endIndx) return; int pavitVal = input[endIndx]; while (startIndx <= endIndx) { while (input[startIndx] < pavitVal) startIndx++; while (input[endIndx] > pavitVal) endIndx--; if( startIndx <= endIndx){ int tmp = input[startIndx]; input[startIndx] = input[endIndx]; input[endIndx] = tmp; startIndx++; endIndx--; } } sort(input, startIndexOrig, endIndx); sort(input, startIndx, endIndexOrig); } } 

इसके लिए परीक्षण कोड है

 public class StrategyPattern { public static void main(String[] args) { Sorter sorter = new Sorter(); int[] input = new int[] {7,1,23,22,22,11,0,21,1,2,334,45,6,11,2}; System.out.print("Input is : "); for (int i : input) { System.out.print(i + ","); } System.out.println(); sorter.sort(input, Speed.SLOW); } } 

वही उदाहरण http://coder2design.com/strategy-pattern/ से लिया जाता है

क्या आप सुनिश्चित हैं कि "आदेश" की स्थिति एक राज्य पद्धति नहीं है? मेरे पास एक कूल्हे है कि इसकी स्थिति अलग-अलग ढंग से नियंत्रित नहीं की जाएगी।

उदाहरण के लिए विधि पर शिप करें:

 order.Ship(); 
  • अगर शिपिंग विधि की स्थिति के कार्य में भिन्नता है, तो आपके पास एक रणनीति पैटर्न है
  • यदि शिप () विधि केवल तब ही सफल हो जाती है जब आदेश का भुगतान किया जाता है, और आदेश अभी तक नहीं भेजा गया है, आपके पास एक राज्य पैटर्न है

राज्य पैटर्न (और अन्य पैटर्न) का सबसे अच्छा उदाहरण मुझे मिला, " हेड फर्स्ट डिज़ाइन पैटर्न " किताब में था, जो आश्चर्यजनक है एक करीबी सेकंड डेविड कम्प्स के पैटर्न की ब्लॉगिंग श्रृंखला होगी ।

मान लीजिए कि आप किसी एक महीने और वर्ष के 9 वें Xday की गणना करने के लिए एक एल्गोरिथ्म लिखना चाहते हैं, उदाहरण के लिए, अक्टूबर 2014 के दूसरे सोमवार। आप एंड्रॉइड के टाइम क्लास एंड्रॉइड। टेक्स्ट का उपयोग करना चाहते हैं। प्रारूप । तिथि का प्रतिनिधित्व करने के लिए समय, लेकिन आप भी एक सामान्य एल्गोरिथ्म लिखना चाहते हैं जो java.util.Calendar भी लागू कर सकते हैं।

यह जो मैंने किया है।

DatetimeMath.java में:

 public interface DatetimeMath { public Object createDatetime(int year, int month, int day); public int getDayOfWeek(Object datetime); public void increment(Object datetime); } 

TimeMath.java में:

 public class TimeMath implements DatetimeMath { @Override public Object createDatetime(int year, int month, int day) { Time t = new Time(); t.set(day, month, year); t.normalize(false); return t; } @Override public int getDayOfWeek(Object o) { Time t = (Time)o; return t.weekDay; } @Override public void increment(Object o) { Time t = (Time)o; t.set(t.monthDay + 1, t.month, t.year); t.normalize(false); } } 

OrdinalDayOfWeekCalculator.java में, जेनेरिक एल्गोरिदम के साथ वर्ग:

 public class OrdinalDayOfWeekCalculator { private DatetimeMath datetimeMath; public OrdinalDayOfWeekCalculator(DatetimeMath m) { datetimeMath = m; } public Object getDate(int year, int month, int dayOfWeek, int ordinal) { Object datetime = datetimeMath.createDatetime(year, month, 1); if (datetimeMath.getDayOfWeek(datetime) == dayOfWeek) { return datetime; } int xDayCount = 0; while (xDayCount != ordinal) { datetimeMath.increment(datetime); if (datetimeMath.getDayOfWeek(datetime) == dayOfWeek) { xDayCount++; } } return datetime; } } 

मेरे एंड्रॉइड ऐप में, मैं ऐसा कुछ कहूंगा

 OrdinalDayOfWeekCalculator odowc = new OrdinalDayOfWeekCalculator(new TimeMath()); Time canadianThanksgiving = (Time)odowc.getDate( year, Calendar.OCTOBER, Time.MONDAY, 2); 

अगर मैं java.util.Calendar लिए एक ही एल्गोरिथ्म का पुन: उपयोग करना चाहता हूं, तो मैं सिर्फ एक क्लास कैलेंडर मैथ लिखूंगा जो DatetimeMath में तीन तरीकों का क्रियान्वयन करता है और फिर उपयोग करता है

 OrdinalDayOfWeekCalculator odowc2 = new OrdinalDayOfWeekCalculator(new CalendarMath()); Calendar canadianThanksgivingCal = (Calendar)odowc2.getDate( year, Calendar.OCTOBER, Calendar.MONDAY, 2); 

मैंने एक आवेदन में एक काफी जटिल इंजन में रणनीति दृष्टिकोण का उपयोग किया है जो कि एक अच्छा उदाहरण है। अनिवार्य रूप से इंजन की भूमिका निभानी थी और पहले उन लोगों की सूची पायी जाती थी जिनके पास विजेट था, यह दूसरी भूमिका है कि यह पता लगाना था कि कौन-से 10 पैरामीटर पैरामीटर के साथ अज्ञात संख्या के आधार पर हैं , स्टॉक पर अमाउंट, शिपिंग ऑप्शंस इत्यादि आदि … आदि)

मूल रूप से हमने जो किया, हमने पहली बार डेटा पुनर्प्राप्ति की दो रणनीतियों में समस्या को तोड़ दिया, क्योंकि हमें पता था कि हमारे विगेट्स के कई स्रोत थे और हमें डेटा प्राप्त करने और एक सामान्य संरचना में बदलने की जरूरत थी।

हमने यह भी महसूस किया कि हमारे पास कई एल्गोरिदम थे, कुछ पैरामीटर के भार पर आधारित थे, अन्य बहुत ही अजीब और स्वामित्व थे और मैं उन्हें विज़िओस और चार्ट खींचने के बिना न्याय नहीं कर सका और अच्छी तरह से आप चित्र प्राप्त करते हैं, हमारे पास बहुत सारे एल्गोरिदम थे सर्वश्रेष्ठ लोगों का चयन

हमारी सेवा में यह बहुत ही महत्वपूर्ण है कि यह आवश्यक रूप से इनपुट, आउटपुट और डेटा के कुछ सामान्यीकरण को परिभाषित करता है, इसने एक प्रदाता पैटर्न को ऐप्लिकेशन विशिष्ट डेटा प्रदाताओं और एल्गोरिथिम प्रदाताओं के प्लग-इन में भी उपयोग किया, जो रणनीति का इस्तेमाल करते थे। यह एक काफी प्रभावी प्रणाली थी।

हमारे पास कुछ बहस थी, यदि हम एक रणनीति या टेम्प्लेट पैटर्न का उपयोग कर रहे थे जिसे हमने कभी हल नहीं किया था।

कुछ हफ्ते पहले, मैंने एक सामान्य जावा इंटरफ़ेस जोड़ा जो हमारे किसी डोमेन ऑब्जेक्ट द्वारा लागू किया गया था। यह डोमेन ऑब्जेक्ट डेटाबेस से लोड किया गया था, और डेटाबेस का प्रतिनिधित्व 10 + शाखाओं के साथ एक स्टार स्कीमा था इस तरह के एक भारी वजन डोमेन ऑब्जेक्ट होने के एक परिणाम यह है कि हमें अन्य डोमेन ऑब्जेक्ट बनाने पड़ते हैं जो कि समान ही स्कीमा का प्रतिनिधित्व करते हैं, हालांकि कम हेवीवेट इसलिए मैंने अन्य लाइटवेट ऑब्जेक्ट्स को एक ही इंटरफ़ेस को लागू किया। अन्यथा रखें:

 public interface CollectibleElephant { long getId(); String getName(); long getTagId(); } public class Elephant implements CollectibleElephant { ... } public class BabyElephant implements CollectibleElephant { ... } 

मूल रूप से, मैं Elephant एस को सॉर्ट करने के लिए कलेक्टिबल Elephant का उपयोग करना चाहता था बहुत जल्दी, मेरी टीममाइट्स ने सुरक्षा जांच चलाने के लिए CollectibleElephant पर ग्लॉम्ड किया, उन्हें फ़िल्टर करें, क्योंकि वे GUI को भेजते हैं।

हमें एक एंटरप्राइज़ प्लेटफ़ॉर्म के लिए एक बहुत जटिल डाटाबेस के साथ तीसरे पक्ष के प्रावधान इंटरफेस बनाना था। प्रावधान करने के लिए डेटा जमा करना हमारे डेटा प्रकारों की एक सूची के रूप में था, जिन्हें हमारे आवेदन में प्राथमिकता कतार में रखा गया था ताकि वे निर्भरता के कारण सही क्रम में डेटाबेस को लिखे जा सकें।

उस डेटा को लिखने की प्रक्रिया तब काफी सरल थी, प्राथमिकता कतार के शीर्ष से ऊपर खिसकते रहते हैं और फिर उस ऑब्जेक्ट के प्रकार के आधार पर एक रणनीति चुनें, जिसे आप निकालते हैं।

 public class StrategyDemo { public static void main(String[] args) { ShoppingCart cart = new ShoppingCart(); Item item1 = new Item("1234", 10); Item item2 = new Item("5678", 40); cart.addItem(item1); cart.addItem(item2); // pay by paypal cart.pay(new PaypalStrategy("myemail@example.com", "mypwd")); // pay by credit card cart.pay(new CreditCardStrategy("Pankaj Kumar", "1234567890123456", "786", "12/15")); } } interface PaymentStrategy { public void pay(int amount); } class CreditCardStrategy implements PaymentStrategy { private String name; private String cardNumber; private String cvv; private String dateOfExpiry; public CreditCardStrategy(String nm, String ccNum, String cvv, String expiryDate) { this.name = nm; this.cardNumber = ccNum; this.cvv = cvv; this.dateOfExpiry = expiryDate; } @Override public void pay(int amount) { System.out.println(amount + " paid with credit/debit card"); } } class PaypalStrategy implements PaymentStrategy { private String emailId; private String password; public PaypalStrategy(String email, String pwd) { this.emailId = email; this.password = pwd; } @Override public void pay(int amount) { System.out.println(amount + " paid using Paypal."); } } class Item { private String upcCode; private int price; public Item(String upc, int cost) { this.upcCode = upc; this.price = cost; } public String getUpcCode() { return upcCode; } public int getPrice() { return price; } } class ShoppingCart { // List of items List<Item> items; public ShoppingCart() { this.items = new ArrayList<Item>(); } public void addItem(Item item) { this.items.add(item); } public void removeItem(Item item) { this.items.remove(item); } public int calculateTotal() { int sum = 0; for (Item item : items) { sum += item.getPrice(); } return sum; } public void pay(PaymentStrategy paymentMethod) { int amount = calculateTotal(); paymentMethod.pay(amount); } }