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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

जाओ
<वाक्यविन्यास प्रकाश लैंग = जाओ> पैकेज डेकोलॉग

आयात ( लकड़ी का लट्ठा समय )

//OperateFn उन ऑपरेशनों का प्रतिनिधित्व करता है जिन्हें सजावट की आवश्यकता होती है ऑपरेटFn func टाइप करें

// ऑपरेशन को सजाएं func डेकोरेट (opFn ऑपरेटFn) { defer func (समय। समय) { log.Printf(बीता हुआ समय %0.2d एमएस, time.Since(s).Nanoseconds / 1000000) }(अब समय)

// वास्तविक ऑपरेशन कार्य ओपीएफएन }

// पैकेज मुख्य मुख्य पैकेज

आयात ( github.com/tkstorm/go-design/structural/decorator/decolog लकड़ी का लट्ठा गणित/रैंड समय )

// आउटपुट: //2019/08/19 19:05:24 समाप्त कार्रवाई ए //2019/08/19 19:05:24 बीता हुआ समय 77 एमएस //2019/08/19 19:05:24 समाप्त कार्रवाई ख //2019/08/19 19:05:24 बीता हुआ समय 88 एमएस फंक मेन { // सजावटी लॉग ए decolog.Decorate (decolog.OperateFn (DoActionA)) // सजावटी लॉग बी decolog.Decorate (decolog.OperateFn (DoActionB)) }

func DoActionA { समय। नींद (समय। अवधि (रैंड। इंटन (200)) * समय। मिलीसेकंड) log.Println (कार्रवाई समाप्त करें ए) }

func DoActionB { समय। नींद (समय। अवधि (रैंड। इंटन (200)) * समय। मिलीसेकंड) log.Println (कार्रवाई ख समाप्त करें) } 

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

डायनेमिक डेकोरेटर
<वाक्यविन्यास लैंग = सीपीपी>
 * 1) शामिल
 * 2) शामिल <स्ट्रिंग>

संरचना आकार { आभासी ~ आकार = डिफ़ॉल्ट;

आभासी एसटीडी :: स्ट्रिंग GetName const = 0; };

संरचना वृत्त : आकार { शून्य आकार (फ्लोट कारक) {त्रिज्या * = कारक; }

एसटीडी :: स्ट्रिंग GetName कास्ट अधिभावी { वापसी एसटीडी�:: स्ट्रिंग (त्रिज्या का एक चक्र) + एसटीडी�:: to_string (त्रिज्या); }

फ्लोट त्रिज्या = 10.0f; };

संरचना रंगीन आकार : आकार { ColoredShape (स्थिरांक एसटीडी :: स्ट्रिंग और रंग, आकार * आकार) : रंग (रंग), आकार (आकार) {}

एसटीडी :: स्ट्रिंग GetName कास्ट अधिभावी { वापसी का आकार-> GetName + जो रंगीन + रंग है; }

एसटीडी :: स्ट्रिंग रंग; आकार * आकार; };

मुख्य प्रवेश बिंदु { सर्किल सर्कल; रंगीन आकार रंगीन_आकार (लाल, और सर्कल); एसटीडी :: अदालत << color_shape.GetName << एसटीडी :: endl;

}  <वाक्यविन्यास लैंग = सीपीपी>


 * 1) शामिल <मेमोरी>
 * 2) शामिल
 * 3) शामिल <स्ट्रिंग>

स्ट्रक्चर वेबपेज {   आभासी शून्य प्रदर्शन  = 0; आभासी ~ वेबपेज = डिफ़ॉल्ट; };

स्ट्रक्चर आधारिक वेबपेज: वेबपेज {   एसटीडी :: स्ट्रिंग एचटीएमएल; शून्य प्रदर्शन अधिभावी {       एसटीडी�:: अदालत << आधारिक वेब पेज << एसटीडी�:: एंडएल; } };

स्ट्रक्चर वेबपेज डेकोरेटर: वेबपेज {   WebPageDecorator(std::unique_ptr webPage): _webPage(std::move(webPage)) {   }    शून्य प्रदर्शन  अधिभावी {       _वेबपेज-> डिस्प्ले ; } निजी: एसटीडी :: Unique_ptr <वेबपेज> _webPage; };

स्ट्रक्चर ऑथेंटिकेटेड वेबपेज: वेबपेज डेकोरेटर {   प्रमाणीकृतवेबपेज(std::unique_ptr<वेबपेज>वेबपेज): वेबपेज डेकोरेटर (एसटीडी :: मूव (वेबपेज)) {}

शून्य प्रमाणीकरण उपयोगकर्ता {       एसटीडी�:: अदालत << प्रमाणीकरण किया << एसटीडी�:: endl; }   शून्य प्रदर्शन  अधिभावी {       प्रमाणित उपयोगकर्ता ; वेबपेजडेकोरेटर�:: प्रदर्शन ; } };

संरचना अधिकृत वेबपेज: वेबपेजडेकोरेटर {   अधिकृतवेबपेज(std::unique_ptr<वेबपेज>वेबपेज): वेबपेज डेकोरेटर (एसटीडी :: मूव (वेबपेज)) {}

शून्य प्राधिकृत उपयोगकर्ता {       std::cout << अधिकृत किया << std::endl; }   शून्य प्रदर्शन  अधिभावी {       अधिकृत उपयोगकर्ता ; वेबपेजडेकोरेटर�:: प्रदर्शन ; } };

इंट मेन (इंट एआरजीसी, चार * एआरजीवी []) {   std::unique_ptrmyPage = std::make_unique;

myPage = std::make_unique(std::move(myPage)); myPage = std::make_unique(std::move(myPage)); मायपेज-> डिस्प्ले ; एसटीडी :: अदालत << एसटीडी :: endl; वापसी 0; }



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

<वाक्यविन्यास लैंग = सीपीपी>
 * 1) शामिल
 * 2) शामिल <स्ट्रिंग>

संरचना सर्किल { शून्य आकार (फ्लोट कारक) {त्रिज्या * = कारक; }

एसटीडी :: स्ट्रिंग GetName कास्ट { वापसी एसटीडी :: स्ट्रिंग (त्रिज्या का एक चक्र) + एसटीडी :: to_string (त्रिज्या); }

फ्लोट त्रिज्या = 10.0f; };

टेम्पलेट <टाइपनाम टी> संरचना रंगीन आकार: सार्वजनिक टी { रंगीन आकार (स्थिरांक एसटीडी :: स्ट्रिंग और रंग): रंग (रंग) {}

एसटीडी :: स्ट्रिंग GetName कास्ट { वापसी टी :: GetName + जो रंगीन + रंग है; }

एसटीडी :: स्ट्रिंग रंग; };

मुख्य प्रवेश बिंदु { ColoredShape red_circle( red ); एसटीडी :: अदालत << red_circle.GetName << एसटीडी :: endl; red_circle.Resize (1.5f); एसटीडी :: अदालत << red_circle.GetName << एसटीडी :: endl; }



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

<वाक्यविन्यास प्रकाश लैंग = जावा> // विंडो इंटरफ़ेस वर्ग सार्वजनिक इंटरफ़ेस विंडो { शून्य ड्रा ; // विंडो ड्रा करें स्ट्रिंग getDescription ; // विंडो का विवरण लौटाता है }

// बिना किसी स्क्रॉलबार के एक साधारण विंडो का कार्यान्वयन वर्ग सिंपलविंडो विंडो लागू करता है { @Override सार्वजनिक शून्य ड्रा { // विंडो ड्रा करें }   @Override सार्वजनिक स्ट्रिंग getDescription { साधारण खिड़की लौटें; } } 

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

<वाक्यविन्यास प्रकाश लैंग = जावा> // अमूर्त डेकोरेटर वर्ग - ध्यान दें कि यह विंडो को लागू करता है सार वर्ग WindowDecorator विंडो लागू करता है { निजी अंतिम विंडो विंडो को सजाने के लिए; // खिड़की को सजाया जा रहा है

सार्वजनिक WindowDecorator (विंडो WindowToBeDecorated) { this.windowToBeDecorated = windowToBeDecorated; }   @Override सार्वजनिक शून्य ड्रा { windowToBeDecorated.draw ; //प्रतिनिधि मंडल }   @Override सार्वजनिक स्ट्रिंग getDescription { वापसी windowToBeDecorated.getDescription; //प्रतिनिधि मंडल } }

// पहला कंक्रीट डेकोरेटर जो लंबवत स्क्रॉलबार कार्यक्षमता जोड़ता है वर्ग VerticalScrollBarDecorator WindowDecorator का विस्तार करता है { सार्वजनिक वर्टिकलस्क्रॉलबार डेकोरेटर (विंडो विंडोटूबीडेकोरेट) { सुपर (windowToBeDecorated); }

@Override सार्वजनिक शून्य ड्रा { सुपर ड्रा ; ड्रा वर्टिकलस्क्रॉलबार ; }

निजी शून्य ड्रा वर्टिकलस्क्रॉलबार { // वर्टिकल स्क्रॉलबार ड्रा करें }

@Override सार्वजनिक स्ट्रिंग getDescription { वापसी super.getDescription +, लंबवत स्क्रॉलबार सहित; } }

// दूसरा कंक्रीट डेकोरेटर जो क्षैतिज स्क्रॉलबार कार्यक्षमता जोड़ता है वर्ग हॉरिज़ॉन्टलस्क्रॉलबारडेकोरेटर विंडोडेकोरेटर का विस्तार करता है { सार्वजनिक क्षैतिज स्क्रॉलबार डिकोरेटर (विंडो विंडो टूबी डेकोरेटेड) { सुपर (windowToBeDecorated); }

@Override सार्वजनिक शून्य ड्रा { सुपर ड्रा ; DrawHorizontalScrollBar; }

निजी शून्य ड्रा क्षैतिज स्क्रॉलबार { // क्षैतिज स्क्रॉलबार ड्रा करें }

@Override सार्वजनिक स्ट्रिंग getDescription { वापसी super.getDescription +, क्षैतिज स्क्रॉलबार सहित; } } 

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

<वाक्यविन्यास प्रकाश लैंग = जावा> पब्लिक वर्ग डेकोरेटेड विन्डोटेस्ट { सार्वजनिक स्थैतिक शून्य main (String [] args) { // क्षैतिज और लंबवत स्क्रॉलबार के साथ एक सजाया हुआ विंडो बनाएं विंडो डेकोरेटेडविंडो = नया हॉरिजॉन्टलस्क्रॉलबारडेकोरेटर (               नया वर्टिकलस्क्रॉलबार डेकोरेटर (नया सिंपलविंडो ));

// विंडो का विवरण प्रिंट करें System.out.println (सजाया गयाWindow.getDescription ); } } 

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

नीचे टेस्ट ड्रिवेन डेवलपमेंट के लिए JUnit टेस्ट वर्ग है <वाक्यविन्यास प्रकाश लैंग = जावा> स्थैतिक org.junit.Assert.assertEquals आयात करें;

आयात org.junit.Test;

पब्लिक वर्ग विंडोडेकोरेटर टेस्ट { @परीक्षा सार्वजनिक शून्य परीक्षण विन्डोडेकोरेटर टेस्ट { विंडो डेकोरेटेडविंडो = नया हॉरिजॉन्टलस्क्रॉलबारडेकोरेटर (नया वर्टिकलस्क्रॉलबारडेकोरेटर (नया सिंपलविंडो )); // दावा करें कि विवरण में वास्तव में क्षैतिज + लंबवत स्क्रॉलबार शामिल हैं AssertEquals (सरल विंडो, वर्टिकल स्क्रॉलबार सहित, हॉरिजॉन्टल स्क्रॉलबार सहित, डेकोरेटेड विन्डो.गेटडिस्क्रिप्शन ); } }



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

<वाक्यविन्यास प्रकाश लैंग = जावा> // इंटरफ़ेस कॉफी डेकोरेटर द्वारा कार्यान्वित कॉफी की कार्यक्षमता को परिभाषित करता है सार्वजनिक इंटरफ़ेस कॉफ़ी { सार्वजनिक डबल गेटकॉस्ट ; // कॉफी की लागत लौटाता है सार्वजनिक स्ट्रिंग 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), छपाई


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

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

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

टिप्पणी:

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

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

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

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

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

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

वर्ग कॉफीडेकोरेटर <कॉफी संरक्षित गेट्टर डेकोरेटेड_कॉफ़ी : कॉफ़ी
 * 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; सामग्री: कॉफी, दूध, स्प्रिंकल्स </पूर्व>

यह भी देखें

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

बाहरी संबंध

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