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

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

अवलोकन

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

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

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

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

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

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

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

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

विचार

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

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

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

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

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

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

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

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

प्रेरणा

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

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

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

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

सामान्य उपयोग की स्तिथियां

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

संरचना

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

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

उपरोक्त यूनिफाइड मॉडलिंग लैंग्वेज वर्ग आरेख में, अमूर्त 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());
	}
}

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

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

इस उदाहरण में, परिदृश्य में केवल लागत और सामग्री सम्मिलित हैं।

// The interface Coffee defines the functionality of Coffee implemented by decorator
public interface Coffee {
    public double getCost(); // Returns the cost of the coffee
    public String getIngredients(); // Returns the ingredients of the coffee
}

// Extension of a simple coffee without any extra ingredients
public class SimpleCoffee implements Coffee {
    @Override
    public double getCost() {
        return 1;
    }

    @Override
    public String getIngredients() {
        return "Coffee";
    }
}

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

// Abstract decorator class - note that it implements Coffee interface
public abstract class CoffeeDecorator implements Coffee {
    private final Coffee decoratedCoffee;

    public CoffeeDecorator(Coffee c) {
        this.decoratedCoffee = c;
    }

    @Override
    public double getCost() { // Implementing methods of the interface
        return decoratedCoffee.getCost();
    }

    @Override
    public String getIngredients() {
        return decoratedCoffee.getIngredients();
    }
}

// Decorator WithMilk mixes milk into coffee.
// Note it extends CoffeeDecorator.
class WithMilk extends CoffeeDecorator {
    public WithMilk(Coffee c) {
        super(c);
    }

    @Override
    public double getCost() { // Overriding methods defined in the abstract superclass
        return super.getCost() + 0.5;
    }

    @Override
    public String getIngredients() {
        return super.getIngredients() + ", Milk";
    }
}

// Decorator WithSprinkles mixes sprinkles onto coffee.
// Note it extends CoffeeDecorator.
class WithSprinkles extends CoffeeDecorator {
    public WithSprinkles(Coffee c) {
        super(c);
    }

    @Override
    public double getCost() {
        return super.getCost() + 0.2;
    }

    @Override
    public String getIngredients() {
        return super.getIngredients() + ", Sprinkles";
    }
}

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

public class Main {
    public static void printInfo(Coffee c) {
        System.out.println("Cost: " + c.getCost() + "; Ingredients: " + c.getIngredients());
    }

    public static void main(String[] args) {
        Coffee c = new SimpleCoffee();
        printInfo(c);

        c = new WithMilk(c);
        printInfo(c);

        c = new WithSprinkles(c);
        printInfo(c);
    }
}

इस कार्यक्रम का आउटपुट नीचे दिया गया है:

Cost: 1.0; Ingredients: Coffee
Cost: 1.5; Ingredients: Coffee, Milk
Cost: 1.7; Ingredients: Coffee, Milk, Sprinkles

पीएचपी

abstract class Component
{
    protected $data;
    protected $value;

    abstract public function getData();

    abstract public function getValue();
}

class ConcreteComponent extends Component
{
    public function __construct()
    {
        $this->value = 1000;
        $this->data = "Concrete Component:\t{$this->value}\n";
    }

    public function getData()
    {
        return $this->data;
    }

    public function getValue()
    {
        return $this->value;
    }
}

abstract class Decorator extends Component
{
    
}

class ConcreteDecorator1 extends Decorator
{
    public function __construct(Component $data)
    {
        $this->value = 500;
        $this->data = $data;
    }

    public function getData()
    {
        return $this->data->getData() . "Concrete Decorator 1:\t{$this->value}\n";
    }

    public function getValue()
    {
        return $this->value + $this->data->getValue();
    }
}

class ConcreteDecorator2 extends Decorator
{
    public function __construct(Component $data)
    {
        $this->value = 500;
        $this->data = $data;
    }

    public function getData()
    {
        return $this->data->getData() . "Concrete Decorator 2:\t{$this->value}\n";
    }

    public function getValue()
    {
        return $this->value + $this->data->getValue();
    }
}

class Client
{
    private $component;

    public function __construct()
    {
        $this->component = new ConcreteComponent();
        $this->component = $this->wrapComponent($this->component);

        echo $this->component->getData();
        echo "Client:\t\t\t";
        echo $this->component->getValue();
    }

    private function wrapComponent(Component $component)
    {
        $component1 = new ConcreteDecorator1($component);
        $component2 = new ConcreteDecorator2($component1);
        return $component2;
    }
}

$client = new Client();

// Result: #quanton81

//Concrete Component:	1000
//Concrete Decorator 1:	500
//Concrete Decorator 2:	500
//Client:               2000

पायथन

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

"""
Demonstrated decorators in a world of a 10x10 grid of values 0-255. 
"""

import random


def s32_to_u16(x):
    if x < 0:
        sign = 0xF000
    else:
        sign = 0
    bottom = x & 0x00007FFF
    return bottom | sign


def seed_from_xy(x, y):
    return s32_to_u16(x) | (s32_to_u16(y) << 16)


class RandomSquare:
    def __init__(s, seed_modifier):
        s.seed_modifier = seed_modifier

    def get(s, x, y):
        seed = seed_from_xy(x, y) ^ s.seed_modifier
        random.seed(seed)
        return random.randint(0, 255)


class DataSquare:
    def __init__(s, initial_value=None):
        s.data = [initial_value] * 10 * 10

    def get(s, x, y):
        return s.data[(y * 10) + x]  # yes: these are all 10x10

    def set(s, x, y, u):
        s.data[(y * 10) + x] = u


class CacheDecorator:
    def __init__(s, decorated):
        s.decorated = decorated
        s.cache = DataSquare()

    def get(s, x, y):
        if s.cache.get(x, y) == None:
            s.cache.set(x, y, s.decorated.get(x, y))
        return s.cache.get(x, y)


class MaxDecorator:
    def __init__(s, decorated, max):
        s.decorated = decorated
        s.max = max

    def get(s, x, y):
        if s.decorated.get(x, y) > s.max:
            return s.max
        return s.decorated.get(x, y)


class MinDecorator:
    def __init__(s, decorated, min):
        s.decorated = decorated
        s.min = min

    def get(s, x, y):
        if s.decorated.get(x, y) < s.min:
            return s.min
        return s.decorated.get(x, y)


class VisibilityDecorator:
    def __init__(s, decorated):
        s.decorated = decorated

    def get(s, x, y):
        return s.decorated.get(x, y)

    def draw(s):
        for y in range(10):
            for x in range(10):
                print "%3d" % s.get(x, y),
            print


# Now, build up a pipeline of decorators:

random_square = RandomSquare(635)
random_cache = CacheDecorator(random_square)
max_filtered = MaxDecorator(random_cache, 200)
min_filtered = MinDecorator(max_filtered, 100)
final = VisibilityDecorator(min_filtered)

final.draw()

टिप्पणी:

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

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

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

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

क्रिस्टल

abstract class Coffee
  abstract def cost
  abstract def ingredients
end

# Extension of a simple coffee
class SimpleCoffee < Coffee
  def cost
    1.0
  end

  def ingredients
    "Coffee"
  end
end

# Abstract decorator
class CoffeeDecorator < Coffee
  protected getter decorated_coffee : Coffee

  def initialize(@decorated_coffee)
  end

  def cost
    decorated_coffee.cost
  end

  def ingredients
    decorated_coffee.ingredients
  end
end

class WithMilk < CoffeeDecorator
  def cost
    super + 0.5
  end

  def ingredients
    super + ", Milk"
  end
end

class WithSprinkles < CoffeeDecorator
  def cost
    super + 0.2
  end

  def ingredients
    super + ", Sprinkles"
  end
end

class Program
  def print(coffee : Coffee)
    puts "Cost: #{coffee.cost}; Ingredients: #{coffee.ingredients}"
  end

  def initialize
    coffee = SimpleCoffee.new
    print(coffee)

    coffee = WithMilk.new(coffee)
    print(coffee)

    coffee = WithSprinkles.new(coffee)
    print(coffee)
  end
end

Program.new

आउटपुट:

Cost: 1.0; Ingredients: Coffee
Cost: 1.5; Ingredients: Coffee, Milk
Cost: 1.7; Ingredients: Coffee, Milk, Sprinkles

सी#

namespace WikiDesignPatterns;

public interface IBike
{
    string GetDetails();
    double GetPrice();
}

public class AluminiumBike : IBike
{
    public double GetPrice() =>
        100.0;

    public string GetDetails() =>
        "Aluminium Bike";
}

public class CarbonBike : IBike
{
    public double GetPrice() =>
        1000.0;

    public string GetDetails() =>
        "Carbon";
}


public abstract class BikeAccessories : IBike
{
    private readonly IBike _bike;

    public BikeAccessories(IBike bike)
    {
        _bike = bike;
    }

    public virtual double GetPrice() =>
        _bike.GetPrice();


    public virtual string GetDetails() =>
        _bike.GetDetails();
}

public class SecurityPackage : BikeAccessories
{
    public SecurityPackage(IBike bike):base(bike)
    {

    }

    public override string GetDetails() =>
        base.GetDetails() + " + Security Package";

    public override double GetPrice() =>
        base.GetPrice() + 1;
}

public class SportPackage : BikeAccessories
{
    public SportPackage(IBike bike) : base(bike)
    {

    }

    public override string GetDetails() =>
        base.GetDetails() + " + Sport Package";

    public override double GetPrice() =>
        base.GetPrice() + 10;
}

public class BikeShop
{
    public static void UpgradeBike()
    {
        var basicBike = new AluminiumBike();
        BikeAccessories upgraded = new SportPackage(basicBike);
        upgraded = new SecurityPackage(upgraded);

        Console.WriteLine($"Bike: '{upgraded.GetDetails()}' Cost: {upgraded.GetPrice()}");

    }
}

आउटपुट:

Bike: 'Aluminium Bike + Sport Package + Security Package' Cost: 111

रूबी

class AbstractCoffee
  def print
    puts "Cost: #{cost}; Ingredients: #{ingredients}"
  end
end

class SimpleCoffee < AbstractCoffee
  def cost
    1.0
  end

  def ingredients
    "Coffee"
  end
end

class WithMilk < SimpleDelegator
  def cost
    __getobj__.cost + 0.5
  end

  def ingredients
    __getobj__.ingredients + ", Milk"
  end
end

class WithSprinkles < SimpleDelegator
  def cost
    __getobj__.cost + 0.2
  end

  def ingredients
    __getobj__.ingredients + ", Sprinkles"
  end
end

coffee = SimpleCoffee.new
coffee.print

coffee = WithMilk.new(coffee)
coffee.print

coffee = WithSprinkles.new(coffee)
coffee.print

आउटपुट:

Cost: 1.0; Ingredients: Coffee
Cost: 1.5; Ingredients: Coffee, Milk
Cost: 1.7; Ingredients: Coffee, Milk, Sprinkles

यह भी देखें

• समग्र पैटर्न
• एडेप्टर पैटर्न
• सार वर्ग
• पहलू आधारित प्रोग्रामिंग
• अपरिवर्तनीय वस्तु

संदर्भ

बाहरी संबंध

• Decorator Pattern implementation in Java
• Decorator pattern description from the Portland Pattern Repository