डेकोरेटर पैटर्न

From Vigyanwiki
Revision as of 16:03, 18 February 2023 by alpha>Artiverma
Not to be confused with पायथन में "डेकोरेटर्स" की अवधारणा.

वस्तु उन्मुख प्रोग्रामिंग में, डेकोरेटर पैटर्न एक डिज़ाइन पैटर्न (कंप्यूटर विज्ञान) है जो व्यवहार को एक ही कक्षा (कंप्यूटर विज्ञान) से अन्य वस्तुओं के व्यवहार को प्रभावित किए बिना गतिशील रूप से एक व्यक्तिगत वस्तु (कंप्यूटर विज्ञान) में जोड़ने की अनुमति देता है।[1] डेकोरेटर पैटर्न अक्सर एकल उत्तरदायित्व सिद्धांत का पालन करने के लिए उपयोगी होता है, क्योंकि यह कार्यक्षमता को चिंता के अद्धितीय क्षेत्रों के साथ वर्गों के बीच विभाजित करने की अनुमति देता है।[2] और साथ ही खुले-बंद सिद्धांत, एक वर्ग की कार्यक्षमता को संशोधित किए बिना विस्तारित करने की अनुमति देता हैं।[3] उपवर्गीकरण की तुलना में डेकोरेटर का उपयोग अधिक कुशल हो सकता है, क्योंकि किसी वस्तु के व्यवहार को पूरी तरह से नई वस्तु को परिभाषित किए बिना संवर्धित किया जा सकता है।

अवलोकन

डेकोरेटर[4] डिजाइन पैटर्न्स तेईस प्रसिद्ध डिज़ाइन पैटर्न में से एक है; ये वर्णन करते हैं कि पुनरावर्ती डिज़ाइन समस्याओं को कैसे हल किया जाए और लचीले और पुन: प्रयोज्य वस्तु-उन्मुख सॉफ़्टवेयर को डिज़ाइन किया जाए - अर्थात, ऐसी वस्तुएँ जिन्हें लागू करना, बदलना, परीक्षण करना और पुन: उपयोग करना आसान हो जाता है।

यह किन समस्याओं का समाधान कर सकता है?

  • कार्यावधि में गतिशील रूप से किसी वस्तु में जिम्मेदारियों को जोड़ा जाना चाहिए (और उससे हटा दिया जाना चाहिए)।[5]
  • कार्यक्षमता बढ़ाने के लिए उपवर्गीकरण का एक लचीला विकल्प प्रदान किया जाना चाहिए।

उपवर्गीकरण का उपयोग करते समय, विभिन्न उपवर्ग अलग-अलग तरीकों से एक वर्ग का विस्तार करते हैं। लेकिन एक एक्सटेंशन संकलन-समय पर कक्षा के लिए बाध्य है और कार्यावधि पर बदला नहीं जा सकता हैं।[citation needed]


यह किस समाधान का वर्णन करता है?

Decorator वस्तुओं कों परिभाषित करें

  • सभी अनुरोधों को अग्रेषित करके विस्तारित (सजाए गए) ऑब्जेक्ट (Component) के अंतराफलक को पारदर्शी रूप से लागू करें
  • अनुरोध अग्रेषित करने से पहले/बाद में अतिरिक्त कार्यक्षमता निष्पादित करें।

यह कार्यावधि पर गतिशील रूप से ऑब्जेक्ट की कार्यक्षमता बढ़ाने के लिए विभिन्न Decorator वस्तुओं के साथ काम करने की अनुमति देता है।
नीचे यूएमएल वर्ग और अनुक्रम आरेख भी देखें।

इरादा

डेकोरेटर एकीकृत मॉडलिंग भाषा वर्ग डायग्राम

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

  1. डेकोरेटर वर्ग में मूल घटक वर्ग को उपवर्गित करें (यूएमएल आरेख देखें);
  2. डेकोरेटर वर्ग में, एक घटक सूचक को एक क्षेत्र के रूप में जोड़ें;
  3. डेकोरेटर वर्ग में, घटक सूचक को हस्ताक्षर करने के लिए डेकोरेटर निर्माता को एक घटक पास करें;
  4. डेकोरेटर वर्ग में, घटक सूचक के लिए सभी घटक विधियों को अग्रेषित करें; और
  5. कंक्रीटडेकोरेटर वर्ग में, किसी भी घटक विधि को अधिभावी करें जिसके व्यवहार को संशोधित करने की आवश्यकता है।

इस पैटर्न को डिज़ाइन किया गया है ताकि ओवरराइड किए गए तरीकों में एक नई कार्यक्षमता जोड़कर हर बार कई सज्जाकारों को एक-दूसरे के ऊपर रखा जा सकता हैं।

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

सजावट की विशेषताएं (जैसे, विधियाँ, गुण, या अन्य सदस्य) आमतौर पर एक इंटरफ़ेस, mixin (a.k.a. Trait_ (कंप्यूटर_प्रोग्रामिंग)) या वर्ग वंशानुक्रम द्वारा परिभाषित की जाती हैं, जो डेकोरेटर और सजी हुई वस्तु द्वारा साझा की जाती हैं। पिछले उदाहरण में, वर्ग घटक को कंक्रीटघटक और डेकोरेटर से उपवर्ग दोनों द्वारा विरासत में मिला है।

डेकोरेटर पैटर्न उपवर्ग (कंप्यूटर साइंस) आईएनजी का एक विकल्प है। उपवर्गीकरण संकलन समय पर व्यवहार जोड़ता है, और परिवर्तन मूल वर्ग के सभी उदाहरणों को प्रभावित करता है; डेकोरेटिंग चयनित वस्तुओं के लिए कार्यावधि (प्रोग्राम जीवनचक्र चरण) पर नया व्यवहार प्रदान कर सकता है।

कार्यक्षमता बढ़ाने के कई स्वतंत्र तरीके होने पर यह अंतर सबसे महत्वपूर्ण हो जाता है। कुछ वस्तु-उन्मुख प्रोग्रामिंग भाषा में, कक्षाएं रनटाइम पर नहीं बनाई जा सकती हैं, और आमतौर पर यह अनुमान लगाना संभव नहीं है कि डिज़ाइन समय पर एक्सटेंशन के कौन से संयोजन की आवश्यकता होगी। इसका मतलब यह होगा कि हर संभव संयोजन के लिए एक नया वर्ग बनाना होगा। इसके विपरीत, सजावटी वस्तुएँ हैं, जो रनटाइम पर बनाई जाती हैं, और इन्हें प्रति-उपयोग के आधार पर जोड़ा जा सकता है। जावा प्लेटफॉर्म, मानक संस्करण java.io और .NET फ्रेमवर्क दोनों के I/O स्ट्रीम कार्यान्वयन में डेकोरेटर पैटर्न शामिल है।

प्रेरणा

विंडो उदाहरण के लिए यूएमएल आरेख

उदाहरण के तौर पर, विंडोिंग सिस्टम में विंडो पर विचार करें। विंडो की सामग्री को स्क्रॉल करने की अनुमति देने के लिए, कोई भी इसमें क्षैतिज या लंबवत स्क्रॉल बार जोड़ना चाह सकता है, जैसा उपयुक्त हो। मान लें कि विंडोज़ को विंडो इंटरफ़ेस के उदाहरणों द्वारा दर्शाया गया है, और मान लें कि इस वर्ग में स्क्रॉलबार जोड़ने के लिए कोई कार्यक्षमता नहीं है। कोई उपवर्ग स्क्रॉलिंगविंडो बना सकता है जो उन्हें प्रदान करता है, या एक स्क्रॉलिंगविंडोडिकोरेटर बनाता है जो इस कार्यक्षमता को मौजूदा विंडो वस्तु्स में जोड़ता है। इस बिंदु पर, कोई भी समाधान ठीक रहेगा।

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

पिछले उदाहरण में, सिंपलविंडो और विंडोडेकोरेटर वर्ग विंडो इंटरफ़ेस को लागू करते हैं, जो ड्रॉ () विधि और गेटडिस्क्रिप्शन () विधि को परिभाषित करता है, जो विंडो नियंत्रण को सजाने के लिए इस परिदृश्य में आवश्यक हैं।

सामान्य उपयोग के मामले

डेकोरेटर लगाना

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

राज्य में परिवर्तन के आधार पर डेकोरेटरों को लागू करना या हटाना एक अन्य सामान्य उपयोग मामला है। राज्य के दायरे के आधार पर, डेकोरेटर्स को बल्क में लगाया या हटाया जा सकता है। इसी तरह, बदलती कार्यक्षमता को समाहित करने वाले उपवर्गों के बजाय डेकोरेटरों का उपयोग करके अवस्था पैटर्न को लागू किया जा सकता है। इस तरह से डेकोरेटरों का उपयोग राज्य वस्तु की आंतरिक स्थिति और कार्यक्षमता को अधिक रचनात्मक और मनमाना जटिलता से निपटने में सक्षम बनाता है।

फ्लाईवेट वस्तु्स में उपयोग

Main article: फ्लाईवेट सजाना

फ्लाईवेट पैटर्न में सजावट का भी अक्सर उपयोग किया जाता है। फ्लाईवेट ऑब्जेक्ट्स को दो घटकों में विभाजित किया गया है: एक अपरिवर्तनीय घटक जो सभी फ्लाईवेट ऑब्जेक्ट्स और एक वेरिएंट, सजाए गए घटक के बीच साझा किया जाता है जो आंशिक रूप से साझा किया जा सकता है या पूरी तरह से साझा नहीं किया जा सकता है। फ्लाईवेट ऑब्जेक्ट के इस विभाजन का उद्देश्य स्मृति खपत को कम करना है। सज्जाकार आमतौर पर कैश और पुन: उपयोग किए जाते हैं। सज्जाकार सभी में साझा, अपरिवर्तनीय वस्तु का एक सामान्य संदर्भ होगा। यदि सजाया गया राज्य केवल आंशिक रूप से भिन्न होता है, तो डेकोरेटर्स को भी कुछ हद तक साझा किया जा सकता है - हालांकि ध्यान रखा जाना चाहिए कि उनका उपयोग किए जाने के दौरान उनकी स्थिति में बदलाव न हो। iOS का UITableView फ्लाईवेट पैटर्न को इस तरीके से लागू करता है - एक टेबलव्यू की पुन: प्रयोज्य कोशिकाएं सज्जाकार होती हैं जिनमें एक सामान्य टेबलव्यू पंक्ति वस्तु के संदर्भ होते हैं, और कोशिकाओं को कैश / पुन: उपयोग किया जाता है।

डेकोरेटर्स के साथ इंटरफेसिंग की बाधाएं

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

वास्तु प्रासंगिकता

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

उपरोक्त कारणों से डेकोरेटरों को अक्सर उप-वर्गीकरण के लिए स्मृति-कुशल विकल्प माना जाता है।

डेकोरेटर्स का उपयोग उन वस्तुओं को विशेषज्ञ बनाने के लिए भी किया जा सकता है जो उपवर्गीय नहीं हैं, जिनकी विशेषताओं को रनटाइम पर बदलने की आवश्यकता है (जैसा कि कहीं और उल्लेख किया गया है), या आमतौर पर ऐसी वस्तुएं जिनमें कुछ आवश्यक कार्यक्षमता की कमी है।

एपीआई बढ़ाने में उपयोग

डेकोरेटर पैटर्न भी फेकाडे पैटर्न को बढ़ा सकता है। एक फकड़े को जटिल प्रणाली के साथ इंटरफेस करने के लिए डिज़ाइन किया गया है, लेकिन यह सिस्टम में कार्यक्षमता नहीं जोड़ता है। हालाँकि, एक जटिल प्रणाली का रैपिंग एक स्थान प्रदान करता है जिसका उपयोग सिस्टम में उप-घटकों के समन्वय के आधार पर नई कार्यक्षमता को पेश करने के लिए किया जा सकता है।

उदाहरण के लिए, एक बहु-भाषा शब्दकोश इंटरफ़ेस के तहत एक फकड़े पैटर्न कई अलग-अलग भाषाओं के शब्दकोशों को एकजुट कर सकता है। नया इंटरफ़ेस भाषाओं के बीच शब्दों के अनुवाद के लिए नए कार्य भी प्रदान कर सकता है।

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

डेकोरेटर के विकल्प

डेकोरेटर पैटर्न के विकल्प के रूप में, एडेप्टर पैटर्न का उपयोग तब किया जा सकता है जब रैपर को किसी विशेष इंटरफ़ेस का सम्मान करना चाहिए और बहुरूपता (कंप्यूटर विज्ञान) व्यवहार का समर्थन करना चाहिए, और जब किसी अंतर्निहित वस्तु के लिए एक आसान या सरल इंटरफ़ेस वांछित होता है।[6]

पैटर्न उद्देश्य
अडैप्टर एक इंटरफ़ेस को दूसरे में परिवर्तित करता है ताकि यह ग्राहक की अपेक्षा से मेल खाता हो
डेकोरेटर मूल कोड को लपेटकर गतिशील रूप से इंटरफ़ेस में जिम्मेदारी जोड़ता है
फकड़े एक सरलीकृत इंटरफ़ेस प्रदान करता है


संरचना

यूएमएल वर्ग और अनुक्रम आरेख

डेकोरेटर डिजाइन पैटर्न के लिए एक मानक यूएमएल वर्ग और अनुक्रम आरेख। [7]

उपरोक्त यूनिफाइड मॉडलिंग लैंग्वेज वर्ग आरेख में, अमूर्त Decorator वर्ग सजावटी वस्तु (component) के लिए एक संदर्भ (Component) बनाए रखता है और इसके लिए सभी अनुरोधों (component.operation()) को अग्रेषित करता है.

उपवर्ग (Decorator1,Decorator2) अतिरिक्त व्यवहार (addBehavior()) को लागू करते हैं जिसे घटक Component (इसे अनुरोध अग्रेषित करने से पहले/बाद में) में जोड़ा जाना चाहिए।
अनुक्रम आरेख कार्यावधि इंटरैक्शन दिखाता है: Client वस्तु Decorator1 और वस्त्तु की कार्यक्षमता बढ़ाने के लिए Decorator1 और Decorator2 वस्तुओं के माध्यम से काम करता है।
Client Decorator1 operation() कॉल करता है, जो Decorator2 के अनुरोध को आगे बढ़ाता है।Decorator2 Component1 के अनुरोध को अग्रेषित करने के बाद addBehavior() निष्पादित करता है और Decorator1 पर लौट जाता है, जो addBehavior() करता है और Client कों वापस करता है

उदाहरण

जाओ

package decolog

import (
	"log"
	"time"
)

//OperateFn represents operations that require decoration
type OperateFn func()

//Decorate the operation
func Decorate(opFn OperateFn)  {
	defer func(s time.Time) {
		log.Printf("elapsed time %0.2d ms", time.Since(s).Nanoseconds() / 1000000)
	}(time.Now())

	// real operation function
	opFn()
}

// package main
package main

import (
	"github.com/tkstorm/go-design/structural/decorator/decolog"
	"log"
	"math/rand"
	"time"
)

//output:
//2019/08/19 19:05:24 finish action a
//2019/08/19 19:05:24 elapsed time 77 ms
//2019/08/19 19:05:24 finish action b
//2019/08/19 19:05:24 elapsed time 88 ms
func main() {
	// decorate log a
	decolog.Decorate(decolog.OperateFn(DoActionA))
	// decorate log b
	decolog.Decorate(decolog.OperateFn(DoActionB))
}

func DoActionA() {
	time.Sleep(time.Duration(rand.Intn(200)) * time.Millisecond)
	log.Println("finish action a")
}

func DoActionB() {
	time.Sleep(time.Duration(rand.Intn(200)) * time.Millisecond)
	log.Println("finish action b")
}

सी ++

यहां दो विकल्प प्रस्तुत किए गए हैं: पहला, एक डायनेमिक, रनटाइम-कंपोज़ेबल डेकोरेटर (सजाए गए कार्यों को कॉल करने में समस्या है जब तक कि स्पष्ट रूप से प्रॉक्सी न हो) और एक डेकोरेटर जो मिक्सिन इनहेरिटेंस का उपयोग करता है।

डायनेमिक डेकोरेटर

#include <iostream>
#include <string>

struct Shape {
  virtual ~Shape() = default;

  virtual std::string GetName() const = 0;
};

struct Circle : Shape {
  void Resize(float factor) { radius *= factor; }

  std::string GetName() const override {
    return std::string("A circle of radius ") + std::to_string(radius);
  }

  float radius = 10.0f;
};

struct ColoredShape : Shape {
  ColoredShape(const std::string& color, Shape* shape)
      : color(color), shape(shape) {}

  std::string GetName() const override {
    return shape->GetName() + " which is colored " + color;
  }

  std::string color;
  Shape* shape;
};

int main() {
  Circle circle;
  ColoredShape colored_shape("red", &circle);
  std::cout << colored_shape.GetName() << std::endl;

}
#include <memory>
#include <iostream>
#include <string>

struct WebPage
{
    virtual void display()=0;
    virtual ~WebPage() = default;
};

struct BasicWebPage : WebPage
{
    std::string html;
    void display() override
    {
        std::cout << "Basic WEB page" << std::endl;
    }
};

struct WebPageDecorator : WebPage
{
    WebPageDecorator(std::unique_ptr<WebPage> webPage): _webPage(std::move(webPage))
    {
    }
    void display() override
    {
        _webPage->display();
    }
private:
    std::unique_ptr<WebPage> _webPage;
};

struct AuthenticatedWebPage : WebPageDecorator
{
    AuthenticatedWebPage(std::unique_ptr<WebPage> webPage): 
    WebPageDecorator(std::move(webPage))
    {}

    void authenticateUser()
    {
        std::cout << "authentification done" << std::endl;
    }
    void display() override
    {
        authenticateUser();
        WebPageDecorator::display();
    }
};

struct AuthorizedWebPage : WebPageDecorator
{
    AuthorizedWebPage(std::unique_ptr<WebPage> webPage): 
    WebPageDecorator(std::move(webPage))
    {}

    void authorizedUser()
    {
        std::cout << "authorized done" << std::endl;
    }
    void display() override
    {
        authorizedUser();
        WebPageDecorator::display();
    }
};

int main(int argc, char* argv[])
{
    std::unique_ptr<WebPage> myPage = std::make_unique<BasicWebPage>();

    myPage = std::make_unique<AuthorizedWebPage>(std::move(myPage));
    myPage = std::make_unique<AuthenticatedWebPage>(std::move(myPage));
    myPage->display();
    std::cout << std::endl;
    return 0;
}

स्टेटिक डेकोरेटर (मिक्सिन इनहेरिटेंस)

यह उदाहरण एक स्थिर डेकोरेटर कार्यान्वयन को प्रदर्शित करता है, जो टेम्पलेट तर्क से इनहेरिट करने की C++ क्षमता के कारण संभव है।

#include <iostream>
#include <string>

struct Circle {
  void Resize(float factor) { radius *= factor; }

  std::string GetName() const {
    return std::string("A circle of radius ") + std::to_string(radius);
  }

  float radius = 10.0f;
};

template <typename T>
struct ColoredShape : public T {
  ColoredShape(const std::string& color) : color(color) {}

  std::string GetName() const {
    return T::GetName() + " which is colored " + color;
  }

  std::string color;
};

int main() {
  ColoredShape<Circle> red_circle("red");
  std::cout << red_circle.GetName() << std::endl;
  red_circle.Resize(1.5f);
  std::cout << red_circle.GetName() << std::endl;
}

जावा

पहला उदाहरण (विंडो/स्क्रॉलिंग परिदृश्य)

निम्न जावा उदाहरण विंडो/स्क्रॉलिंग परिदृश्य का उपयोग कर सजावटी के उपयोग को दिखाता है।

// The Window interface class
public interface Window {
    void draw(); // Draws the Window
    String getDescription(); // Returns a description of the Window
}

// Implementation of a simple Window without any scrollbars
class SimpleWindow implements Window {
    @Override
    public void draw() {
        // Draw window
    }
    @Override
    public String getDescription() {
        return "simple window";
    }
}

निम्नलिखित वर्गों में सभी के लिए डेकोरेटर हैं Window कक्षाएं, डेकोरेटर कक्षाओं सहित स्वयं।

// abstract decorator class - note that it implements Window
abstract class WindowDecorator implements Window {
    private final Window windowToBeDecorated; // the Window being decorated

    public WindowDecorator (Window windowToBeDecorated) {
        this.windowToBeDecorated = windowToBeDecorated;
    }
    @Override
    public void draw() {
        windowToBeDecorated.draw(); //Delegation
    }
    @Override
    public String getDescription() {
        return windowToBeDecorated.getDescription(); //Delegation
    }
}

// The first concrete decorator which adds vertical scrollbar functionality
class VerticalScrollBarDecorator extends WindowDecorator {
    public VerticalScrollBarDecorator (Window windowToBeDecorated) {
        super(windowToBeDecorated);
    }

    @Override
    public void draw() {
        super.draw();
        drawVerticalScrollBar();
    }

    private void drawVerticalScrollBar() {
        // Draw the vertical scrollbar
    }

    @Override
    public String getDescription() {
        return super.getDescription() + ", including vertical scrollbars";
    }
}

// The second concrete decorator which adds horizontal scrollbar functionality
class HorizontalScrollBarDecorator extends WindowDecorator {
    public HorizontalScrollBarDecorator (Window windowToBeDecorated) {
        super(windowToBeDecorated);
    }

    @Override
    public void draw() {
        super.draw();
        drawHorizontalScrollBar();
    }

    private void drawHorizontalScrollBar() {
        // Draw the horizontal scrollbar
    }

    @Override
    public String getDescription() {
        return super.getDescription() + ", including horizontal scrollbars";
    }
}

यहां एक टेस्ट प्रोग्राम है जो एक बनाता है Window उदाहरण जो पूरी तरह से सजाया गया है (यानी, लंबवत और क्षैतिज स्क्रॉलबार के साथ), और इसका विवरण प्रिंट करता है:

public class DecoratedWindowTest {
    public static void main(String[] args) {
        // Create a decorated Window with horizontal and vertical scrollbars
        Window decoratedWindow = new HorizontalScrollBarDecorator (
                new VerticalScrollBarDecorator (new SimpleWindow()));

        // Print the Window's description
        System.out.println(decoratedWindow.getDescription());
    }
}

इस प्रोग्राम का आउटपुट सिंपल विंडो है, जिसमें वर्टिकल स्क्रॉलबार, हॉरिजॉन्टल स्क्रॉलबार शामिल हैं। ध्यान दें कि कैसे getDescription दो डेकोरेटरों की विधि पहले सजाए गए को पुनः प्राप्त करती है Windowका वर्णन करता है और उसे प्रत्यय से अलंकृत करता है। नीचे टेस्ट ड्रिवेन डेवलपमेंट के लिए JUnit टेस्ट वर्ग है

import static org.junit.Assert.assertEquals;

import org.junit.Test;

public class WindowDecoratorTest {
	@Test
	public void testWindowDecoratorTest() {
	    Window decoratedWindow = new HorizontalScrollBarDecorator(new VerticalScrollBarDecorator(new SimpleWindow()));
      	    // assert that the description indeed includes horizontal + vertical scrollbars
            assertEquals("simple window, including vertical scrollbars, including horizontal scrollbars", decoratedWindow.getDescription());
	}
}

दूसरा उदाहरण (कॉफी बनाने का परिदृश्य) asasasasa

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

<वाक्यविन्यास प्रकाश लैंग = जावा> // इंटरफ़ेस कॉफी डेकोरेटर द्वारा कार्यान्वित कॉफी की कार्यक्षमता को परिभाषित करता है सार्वजनिक इंटरफ़ेस कॉफ़ी { 

   सार्वजनिक डबल गेटकॉस्ट (); // कॉफी की लागत लौटाता है
   सार्वजनिक स्ट्रिंग getIngredients (); // कॉफी की सामग्री लौटाता है

}

// बिना किसी अतिरिक्त सामग्री के एक साधारण कॉफी का विस्तार पब्लिक वर्ग सिंपलकॉफी कॉफी लागू करता है { 

   @Override
   सार्वजनिक डबल गेटकॉस्ट () {
       वापसी 1;
   }

   @Override
   सार्वजनिक स्ट्रिंग getIngredients () {
       वापसी कॉफी;
   }

} </वाक्यविन्यास हाइलाइट>

निम्नलिखित वर्गों में सभी के लिए डेकोरेटर हैं Coffee कक्षाएं, डेकोरेटर कक्षाओं सहित स्वयं।

<वाक्यविन्यास प्रकाश लैंग = जावा>

// एब्सट्रैक्ट डेकोरेटर वर्ग - ध्यान दें कि यह कॉफी इंटरफ़ेस को लागू करता है सार्वजनिक सार वर्ग कॉफीडेकोरेटर कॉफी को लागू करता है { 

   निजी अंतिम कॉफी सजाया कॉफी;

   सार्वजनिक कॉफीडेकोरेटर (कॉफी सी) {
       this.decoratedCoffee = c;
   }

   @Override
   सार्वजनिक डबल गेटकॉस्ट () {// इंटरफ़ेस के कार्यान्वयन के तरीके
       सजी हुई कॉफी लौटाएं। getCost ();
   }

   @Override
   सार्वजनिक स्ट्रिंग getIngredients () {
       सजाए गए कॉफ़ी.गेटइन्ग्रेडिएंट्स ();
   }

}

// डेकोरेटर विथ मिल्क कॉफी में दूध मिलाता है। // ध्यान दें कि यह CoffeeDecorator का विस्तार करता है। वर्ग WithMilk कॉफीडेकोरेटर का विस्तार करता है { 

   सार्वजनिक दूध के साथ (कॉफी सी) {
       सुपर (सी);
   }

   @Override
   सार्वजनिक डबल गेटकॉस्ट () {// अमूर्त सुपरवर्ग में परिभाषित विधियों को अधिभावी करना
       रिटर्न सुपर.गेटकॉस्ट () + 0.5;
   }

   @Override
   सार्वजनिक स्ट्रिंग getIngredients () {
       रिटर्न सुपर.गेटइन्ग्रेडिएंट्स () +, दूध;
   }

}

// डेकोरेटर विथस्प्रिंकल्स कॉफ़ी पर स्प्रिंकल्स को मिलाता है। // ध्यान दें कि यह CoffeeDecorator का विस्तार करता है। वर्ग WithSprinkles CoffeeDecorator { का विस्तार करता है 

   पब्लिक विदस्प्रिंकल्स (कॉफी सी) {
       सुपर (सी);
   }

   @Override
   सार्वजनिक डबल गेटकॉस्ट () {
       रिटर्न सुपर.गेटकॉस्ट () + 0.2;
   }

   @Override
   सार्वजनिक स्ट्रिंग getIngredients () {
       रिटर्न सुपर.गेटइन्ग्रेडिएंट्स () +, स्प्रिंकल्स;
   }

} </वाक्यविन्यास हाइलाइट>

यहां एक टेस्ट प्रोग्राम है जो एक बनाता है Coffee उदाहरण जो पूरी तरह से सजाया गया है (दूध और स्प्रिंकल्स के साथ), और कॉफी की लागत की गणना करता है और इसकी सामग्री को प्रिंट करता है:

<वाक्यविन्यास प्रकाश लैंग = जावा> सार्वजनिक वर्ग मुख्य { 

   सार्वजनिक स्थैतिक शून्य प्रिंटइन्फो (कॉफी सी) {
       System.out.println (लागत: + c.getCost () +; सामग्री: + c.getIngredients ());
   }

   सार्वजनिक स्थैतिक शून्य main (String [] args) {
       कॉफ़ी सी = नया सिंपल कॉफ़ी ();
       प्रिंटइन्फो (सी);

       सी = नया दूध के साथ (सी);
       प्रिंटइन्फो (सी);

       सी = नया विथस्प्रिंकल्स (सी);
       प्रिंटइन्फो (सी);
   }

} </वाक्यविन्यास हाइलाइट>

इस कार्यक्रम का आउटपुट नीचे दिया गया है: <पूर्व> लागत: 1.0; सामग्री: कॉफी लागत: 1.5; सामग्री: कॉफी, दूध लागत: 1.7; सामग्री: कॉफी, दूध, स्प्रिंकल्स </पूर्व>

पीएचपी

<वाक्यविन्यास लैंग = php> सार वर्ग घटक { 

   संरक्षित $ डेटा;
   संरक्षित $ मूल्य;

   सार सार्वजनिक समारोह getData ();

   अमूर्त सार्वजनिक समारोह getValue ();

}

वर्ग कंक्रीटघटक घटक का विस्तार करता है { 

   सार्वजनिक समारोह __ निर्माण ()
   {
       $ यह-> मूल्य = 1000;
       $this->data = कंक्रीट घटक:\t{$this->value}\n};
   }

   सार्वजनिक समारोह getData ()
   {
       $ यह-> डेटा वापस करें;
   }

   सार्वजनिक समारोह getValue ()
   {
       वापसी $ यह-> मान;
   }

}

सार वर्ग डेकोरेटर घटक का विस्तार करता है {

}

वर्ग ConcreteDecorator1 डेकोरेटर का विस्तार करता है { 

   सार्वजनिक कार्य __ निर्माण (घटक $ डेटा)
   {
       $ यह-> मूल्य = 500;
       $ यह-> डेटा = $ डेटा;
   }

   सार्वजनिक समारोह getData ()
   {
       $this->data->getData() वापस करें। कंक्रीट डेकोरेटर 1:\t{$this->value}\n ;
   }

   सार्वजनिक समारोह getValue ()
   {
       रिटर्न $this->value + $this->data->getValue();
   }

}

वर्ग ConcreteDecorator2 डेकोरेटर का विस्तार करता है { 

   सार्वजनिक कार्य __ निर्माण (घटक $ डेटा)
   {
       $ यह-> मूल्य = 500;
       $ यह-> डेटा = $ डेटा;
   }

   सार्वजनिक समारोह getData ()
   {
       $this->data->getData() वापस करें। कंक्रीट डेकोरेटर 2:\t{$this->value}\n ;
   }

   सार्वजनिक समारोह getValue ()
   {
       रिटर्न $this->value + $this->data->getValue();
   }

}

वर्ग क्लाइंट { 

   निजी $ घटक;

   सार्वजनिक समारोह __ निर्माण ()
   {
       $ यह-> घटक = नया कंक्रीट कॉम्पोनेंट ();
       $this->component = $this->wrapComponent($this->component);

       प्रतिध्वनि $ यह-> घटक-> getData ();
       इको क्लाइंट:\t\t\t ;
       प्रतिध्वनि $ यह-> घटक-> getValue ();
   }

   निजी कार्य रैप कॉम्पोनेंट (घटक $ घटक)
   {
       $component1 = new ConcreteDecorator1($component);
       $component2 = new ConcreteDecorator2($component1);
       वापसी $component2;
   }

}

$ ग्राहक = नया ग्राहक ();

// परिणाम: # क्वांटन81

// कंक्रीट घटक: 1000 // कंक्रीट डेकोरेटर 1: 500 // कंक्रीट डेकोरेटर 2: 500 // क्लाइंट: 2000 </वाक्यविन्यास हाइलाइट>

पायथन

निम्नलिखित पायथन उदाहरण, Python Wiki - डेकोरेटरपैटर्न से लिया गया है, हमें दिखाता है कि किसी वस्तु में गतिशील रूप से कई व्यवहारों को जोड़ने के लिए पाइपलाइन डेकोरेटर्स कैसे करें:

<वाक्यविन्यास लैंग = अजगर>

0-255 मानों के 10x10 ग्रिड की दुनिया में प्रदर्शित डेकोरेटर।


यादृच्छिक आयात करें


def s32_to_u16(x): 

   अगर एक्स <0:
       साइन = 0xF000
   अन्य:
       चिह्न = 0
   नीचे = एक्स और 0x00007FFF
   नीचे लौटें | संकेत


डीईएफ़ Seed_from_xy (एक्स, वाई): 

   वापसी s32_to_u16(x) | (S32_to_u16(y) << 16)


वर्ग रैंडम स्क्वायर: 

   डीईएफ़ __init__(s, Seed_modifier):
       s.seed_modifier = Seed_modifier

   def get(s, x, y):
       बीज = बीज_से_xy (x, y) ^ s.seed_modifier
       यादृच्छिक बीज (बीज)
       रैंडम रिटर्न रैंडिंट (0, 255)


वर्ग डेटा स्क्वायर: 

   def __init__(s, initial_value=कोई नहीं):
       s.data = [प्रारंभिक_मूल्य] * 10 * 10

   def get(s, x, y):
       वापसी s.data [(y * 10) + x] # हाँ: ये सभी 10x10 हैं

   डीईएफ़ सेट (एस, एक्स, वाई, यू):
       एस डेटा [(वाई * 10) + एक्स] = यू


वर्ग कैशडेकोरेटर: 

   def __init__(s, सजाया गया):
       स.सज्जित = सुशोभित
       s.cache = DataSquare ()

   def get(s, x, y):
       अगर s.cache.get(x, y) == कोई नहीं:
           s.cache.set(x, y, s.decorated.get(x, y))
       वापसी s.cache.get (एक्स, वाई)


वर्ग मैक्सडेकोरेटर: 

   def __init__(s, सजाया गया, अधिकतम):
       स.सज्जित = सुशोभित
       s.max = मैक्स

   def get(s, x, y):
       अगर s.decorated.get(x, y) > s.max:
           रिटर्न एसमैक्स
       रिटर्न s.decorated.get(x, y)


वर्ग मिनडेकोरेटर: 

   डीईएफ़ __init__(एस, सजाया, न्यूनतम):
       स.सज्जित = सुशोभित
       मिनट = मिनट

   def get(s, x, y):
       अगर s.decorated.get(x, y) <s.min:
           वापसी मिनट
       रिटर्न s.decorated.get(x, y)


वर्ग दृश्यता डेकोरेटर: 

   def __init__(s, सजाया गया):
       स.सज्जित = सुशोभित

   def get(s, x, y):
       रिटर्न s.decorated.get(x, y)

   डेफ ड्रा (ओं):
       रेंज में वाई के लिए (10):
           एक्स इन रेंज (10) के लिए:
               प्रिंट %3d % s.get(x, y),
           छपाई


  1. अब, डेकोरेटर्स की एक पाइपलाइन बनाएं:

रैंडम_स्क्वायर = रैंडमस्क्वायर (635) random_cache = CacheDecorator(random_square) max_filtered = MaxDecorator (random_cache, 200) min_filtered = MinDecorator(max_filtered, 100) अंतिम = दृश्यता डेकोरेटर (min_filtered)

अंतिम ड्रा () </वाक्यविन्यास हाइलाइट>

टिप्पणी:

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

दूसरा पायथन विकी के लिए:

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

यह पायथन डेकोरेटर्स के साथ भ्रमित नहीं होना है, जो किसी कार्य या वर्ग को गतिशील रूप से संशोधित करने के लिए एक भाषा सुविधा है।[8]</ब्लॉककोट>

क्रिस्टल

<वाक्यविन्यास लैंग = रूबी> सार वर्ग कॉफी सार डीईएफ़ लागत सार def सामग्री अंत

  1. एक साधारण कॉफी का विस्तार

वर्ग सिंपलकॉफ़ी <कॉफ़ी डीईएफ़ लागत 1.0 अंत

डीईएफ़ सामग्री कॉफ़ी अंत अंत

  1. सार डेकोरेटर

वर्ग कॉफीडेकोरेटर <कॉफी संरक्षित गेट्टर डेकोरेटेड_कॉफ़ी : कॉफ़ी

डीईएफ़ इनिशियलाइज़ (@decorated_coffee) अंत

डीईएफ़ लागत सजाया_कॉफ़ी.लागत अंत

डीईएफ़ सामग्री सजाया_कॉफ़ी.सामग्री अंत अंत

दूध के साथ वर्ग <कॉफीडेकोरेटर डीईएफ़ लागत सुपर + 0.5 अंत

डीईएफ़ सामग्री सुपर +, दूध अंत अंत

वर्ग विदस्प्रिंकल्स <कॉफ़ीडेकोरेटर डीईएफ़ लागत सुपर + 0.2 अंत

डीईएफ़ सामग्री सुपर +, स्प्रिंकल्स अंत अंत

वर्ग कार्यक्रम डेफ प्रिंट (कॉफी: कॉफी) लागत डालता है: #{coffee.cost}; सामग्री: #{coffee.ingredients} अंत

डीईएफ़ इनिशियलाइज़ करें कॉफ़ी = सिंपलकॉफ़ी.नया प्रिंट (कॉफी)

कॉफी = दूध के साथ। नया (कॉफी) प्रिंट (कॉफी)

कॉफ़ी = WithSprinkles.new (कॉफ़ी) प्रिंट (कॉफी) अंत अंत

प्रोग्राम.नया </वाक्यविन्यास हाइलाइट>

आउटपुट: <पूर्व> लागत: 1.0; सामग्री: कॉफी लागत: 1.5; सामग्री: कॉफी, दूध लागत: 1.7; सामग्री: कॉफी, दूध, स्प्रिंकल्स </पूर्व>

सी#

<वाक्यविन्यास प्रकाश लैंग = csharp> नेमस्पेस विकीडिजाइनपैटर्न;

सार्वजनिक इंटरफ़ेस IBike { स्ट्रिंग GetDetails (); डबल गेटप्राइस (); }

पब्लिक वर्ग एल्युमीनियमबाइक: IBike { सार्वजनिक डबल GetPrice () => 100.0;

सार्वजनिक स्ट्रिंग GetDetails () => एल्युमीनियम बाइक; }

पब्लिक वर्ग कार्बनबाइक: आईबाइक { सार्वजनिक डबल GetPrice () => 1000.0;

सार्वजनिक स्ट्रिंग GetDetails () => कार्बन; }


सार्वजनिक अमूर्त वर्ग बाइक सहायक उपकरण: IBike { निजी केवल पढ़ने योग्य IBike _bike;

सार्वजनिक बाइक सहायक उपकरण (आईबाइक बाइक) { _बाइक = बाइक; }

सार्वजनिक आभासी डबल GetPrice () => _bike.GetPrice ();


सार्वजनिक आभासी स्ट्रिंग GetDetails () => _bike.GetDetails (); }

पब्लिक वर्ग सिक्योरिटी पैकेज: बाइक एक्सेसरीज { सार्वजनिक सुरक्षा पैकेज (आईबीइक बाइक): आधार (बाइक) {

}

सार्वजनिक अधिभावी स्ट्रिंग GetDetails () => base.GetDetails() + + सुरक्षा पैकेज;

सार्वजनिक अधिभावी डबल GetPrice () => आधार। GetPrice () + 1; }

पब्लिक वर्ग स्पोर्टपैकेज: बाइक एक्सेसरीज { सार्वजनिक स्पोर्टपैकेज (आईबाइक बाइक): आधार (बाइक) {

}

सार्वजनिक अधिभावी स्ट्रिंग GetDetails () => base.GetDetails() + + स्पोर्ट पैकेज;

सार्वजनिक अधिभावी डबल GetPrice () => आधार। GetPrice () + 10; }

पब्लिक वर्ग बाइकशॉप { सार्वजनिक स्थैतिक शून्य अपग्रेडबाइक () { var आधारिकबाइक = नया एल्युमिनियमबाइक (); बाइक का सामान अपग्रेड किया गया = नया स्पोर्टपैकेज (आधारिकबाइक); उन्नत = नया सुरक्षा पैकेज (उन्नत);

कंसोल.राइटलाइन ($ बाइक: '{upgraded.GetDetails ()}' लागत: {upgraded.GetPrice ()});

} } </वाक्यविन्यास हाइलाइट>

आउटपुट: <पूर्व> बाइक: 'एल्युमीनियम बाइक + स्पोर्ट पैकेज + सुरक्षा पैकेज' कीमत: 111 </पूर्व>

रूबी

<वाक्यविन्यास लैंग = रूबी> वर्ग एब्स्ट्रैक्टकॉफ़ी डेफ प्रिंट डालता लागत: #{लागत}; सामग्री: #{सामग्री} अंत अंत

वर्ग सिंपलकॉफ़ी <एब्स्ट्रैक्टकॉफ़ी डीईएफ़ लागत 1.0 अंत

डीईएफ़ सामग्री कॉफ़ी अंत अंत

वर्ग दूध के साथ <सरल डिलीगेटर डीईएफ़ लागत __getobj__.लागत + 0.5 अंत

डीईएफ़ सामग्री __getobj__.सामग्री +, दूध अंत अंत

वर्ग विथस्प्रिंकल्स <SimpleDelegator डीईएफ़ लागत __getobj__.लागत + 0.2 अंत

डीईएफ़ सामग्री __getobj__. सामग्री +, छिड़काव अंत अंत

कॉफ़ी = सिंपलकॉफ़ी.नया कॉफी प्रिंट

कॉफी = दूध के साथ। नया (कॉफी) कॉफी प्रिंट

कॉफ़ी = WithSprinkles.new (कॉफ़ी) कॉफी प्रिंट

</वाक्यविन्यास हाइलाइट>


आउटपुट: <पूर्व> लागत: 1.0; सामग्री: कॉफी लागत: 1.5; सामग्री: कॉफी, दूध लागत: 1.7; सामग्री: कॉफी, दूध, स्प्रिंकल्स </पूर्व>

यह भी देखें

संदर्भ

  1. ↑ Gamma, Erich; et al. (1995). Design Patterns. Reading, MA: Addison-Wesley Publishing Co, Inc. pp. 175ff. ISBN 0-201-63361-2.
  2. ↑ "How to Implement a Decorator Pattern". Archived from the original on 2015-07-07.
  3. ↑ "The Decorator Pattern, Why We Stopped Using It, and the Alternative".
  4. ↑ Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides (1994). Design Patterns: Elements of Reusable Object-Oriented Software. Addison Wesley. pp. 175ff. ISBN 0-201-63361-2.{{cite book}}: CS1 maint: multiple names: authors list (link)
  5. ↑ "The Decorator design pattern - Problem, Solution, and Applicability". w3sDesign.com. Retrieved 2017-08-12.
  6. ↑ Freeman, Eric; Freeman, Elisabeth; Sierra, Kathy; Bates, Bert (2004). Hendrickson, Mike; Loukides, Mike (eds.). Head First Design Patterns (paperback). Vol. 1. O'Reilly. pp. 243, 252, 258, 260. ISBN 978-0-596-00712-6. Retrieved 2012-07-02.
  7. ↑ "The Decorator design pattern - Structure and Collaboration". w3sDesign.com. Retrieved 2017-08-12.
  8. ↑ "DecoratorPattern - Python Wiki". wiki.python.org.


बाहरी संबंध

The Wikibook Computer Science Design Patterns has a page on the topic of: Decorator implementations in various languages
Retrieved from ‘https://www.vigyanwiki.in/index.php?title=डेकोरेटर_पैटर्न&oldid=105217’