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

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

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

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

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

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

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

यह विभिन्न के साथ काम करने की अनुमति देता है  ऑब्जेक्ट्स रन-टाइम पर किसी ऑब्जेक्ट की कार्यक्षमता को गतिशील रूप से विस्तारित करने के लिए।

नीचे यूएमएल क्लास और सीक्वेंस डायग्राम भी देखें।

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

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

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

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

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

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

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

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

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

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

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

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