डेकोरेटर पैटर्न: Difference between revisions

From Vigyanwiki
No edit summary
No edit summary
Line 3: Line 3:
{{distinguish|text=[[पायथन सिंटैक्स और सिमेंटिक्स#डेकोरेटर्स|पायथन में "डेकोरेटर्स" की अवधारणा]]}}
{{distinguish|text=[[पायथन सिंटैक्स और सिमेंटिक्स#डेकोरेटर्स|पायथन में "डेकोरेटर्स" की अवधारणा]]}}


 
[[ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग|वस्तु उन्मुख प्रोग्रामिंग]] में, डेकोरेटर पैटर्न एक डिज़ाइन पैटर्न (कंप्यूटर विज्ञान) है जो व्यवहार को एक ही [[कक्षा (कंप्यूटर विज्ञान)]] से अन्य वस्तुओं के व्यवहार को प्रभावित किए बिना गतिशील रूप से एक व्यक्तिगत [[वस्तु (कंप्यूटर विज्ञान)]] में जोड़ने की अनुमति देता है।<ref>{{cite book|last=Gamma|first=Erich|title=Design Patterns|year=1995|publisher=Addison-Wesley Publishing Co, Inc.|location=Reading, MA|isbn=0-201-63361-2|pages=[https://archive.org/details/designpatternsel00gamm/page/175 175ff]|display-authors=etal|url=https://archive.org/details/designpatternsel00gamm/page/175}}</ref> डेकोरेटर पैटर्न अक्सर एकल उत्तरदायित्व सिद्धांत का पालन करने के लिए उपयोगी होता है, क्योंकि यह कार्यक्षमता को चिंता के अद्धितीय क्षेत्रों के साथ वर्गों के बीच विभाजित करने की अनुमति देता है।<ref>{{cite web|title=How to Implement a Decorator Pattern |url=http://sam-burns.co.uk/57/how-to-implement-a-decorator-pattern/ |url-status=dead |archive-url=https://web.archive.org/web/20150707165957/http://sam-burns.co.uk/57/how-to-implement-a-decorator-pattern/ |archive-date=2015-07-07 }}</ref> और साथ ही [[ओपन-क्लोज्ड सिद्धांत|खुले-बंद सिद्धांत]], एक वर्ग की कार्यक्षमता को संशोधित किए बिना विस्तारित करने की अनुमति देता हैं।<ref>{{cite web|title=The Decorator Pattern, Why We Stopped Using It, and the Alternative | url=https://betterprogramming.pub/the-decorator-pattern-why-i-stopped-using-it-and-the-alternative-2ae447f9de08}}</ref> उपवर्गीकरण की तुलना में डेकोरेटर का उपयोग अधिक कुशल हो सकता है, क्योंकि किसी वस्तु के व्यवहार को पूरी तरह से नई वस्तु को परिभाषित किए बिना संवर्धित किया जा सकता है।
[[ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग|वस्तु उन्मुख प्रोग्रामिंग]] में, डेकोरेटर पैटर्न एक डिज़ाइन पैटर्न (कंप्यूटर विज्ञान) है जो व्यवहार को एक ही [[कक्षा (कंप्यूटर विज्ञान)]] से अन्य वस्तुओं के व्यवहार को प्रभावित किए बिना गतिशील रूप से एक व्यक्तिगत [[वस्तु (कंप्यूटर विज्ञान)]] में जोड़ने की अनुमति देता है।<ref>{{cite book|last=Gamma|first=Erich|title=Design Patterns|year=1995|publisher=Addison-Wesley Publishing Co, Inc.|location=Reading, MA|isbn=0-201-63361-2|pages=[https://archive.org/details/designpatternsel00gamm/page/175 175ff]|display-authors=etal|url=https://archive.org/details/designpatternsel00gamm/page/175}}</ref> डेकोरेटर पैटर्न अक्सर एकल उत्तरदायित्व सिद्धांत का पालन करने के लिए उपयोगी होता है, क्योंकि यह कार्यक्षमता को चिंता के अनूठे क्षेत्रों के साथ वर्गों के बीच विभाजित करने की अनुमति देता है।<ref>{{cite web|title=How to Implement a Decorator Pattern |url=http://sam-burns.co.uk/57/how-to-implement-a-decorator-pattern/ |url-status=dead |archive-url=https://web.archive.org/web/20150707165957/http://sam-burns.co.uk/57/how-to-implement-a-decorator-pattern/ |archive-date=2015-07-07 }}</ref> और साथ ही [[ओपन-क्लोज्ड सिद्धांत|खुले-बंद सिद्धांत]], एक वर्ग की कार्यक्षमता को संशोधित किए बिना विस्तारित करने की अनुमति देता हैं।<ref>{{cite web|title=The Decorator Pattern, Why We Stopped Using It, and the Alternative | url=https://betterprogramming.pub/the-decorator-pattern-why-i-stopped-using-it-and-the-alternative-2ae447f9de08}}</ref> उपवर्गीकरण की तुलना में डेकोरेटर का उपयोग अधिक कुशल हो सकता है, क्योंकि किसी वस्तु के व्यवहार को पूरी तरह से नई वस्तु को परिभाषित किए बिना संवर्धित किया जा सकता है।


== अवलोकन ==
== अवलोकन ==
Line 30: Line 29:
# डेकोरेटर वर्ग में, एक घटक सूचक को एक क्षेत्र के रूप में जोड़ें;
# डेकोरेटर वर्ग में, एक घटक सूचक को एक क्षेत्र के रूप में जोड़ें;
# डेकोरेटर वर्ग में, घटक सूचक को हस्ताक्षर करने के लिए डेकोरेटर निर्माता को एक घटक पास करें;
# डेकोरेटर वर्ग में, घटक सूचक को हस्ताक्षर करने के लिए डेकोरेटर निर्माता को एक घटक पास करें;
# डेकोरेटर वर्ग में, घटक सूचक के लिए सभी घटक विधियों को अग्रेषित करें; और<!-- {{Clarify|No mention of this in the refs, and the phrase does not make clear which space is lost: the decorated object's, or the decorator's?|date=May 2011}} (This implies that all Decorator fields coming from the Component motherclass will never be used and their memory space will be wasted—That is an accepted drawback of the decorator pattern) -->
# डेकोरेटर वर्ग में, घटक सूचक के लिए सभी घटक विधियों को अग्रेषित करें; और
# कंक्रीटडेकोरेटर वर्ग में, किसी भी घटक विधि को अधिभावी करें जिसके व्यवहार को संशोधित करने की आवश्यकता है।
# कंक्रीटडेकोरेटर वर्ग में, किसी भी घटक विधि को अधिभावी करें जिसके व्यवहार को संशोधित करने की आवश्यकता है।


Line 103: Line 102:


== उदाहरण ==
== उदाहरण ==
<!-- Wikipedia is not a list of examples. Do not add examples from your favorite programming language here; this page exists to explain the design pattern, not to show how it interacts with subtleties of every language under the sun. Feel free to add examples here: http://en.wikibooks.org/wiki/Computer_Science_Design_Patterns/Decorator -->
 




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


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


//OperateFn उन ऑपरेशनों का प्रतिनिधित्व करता है जिन्हें सजावट की आवश्यकता होती है
//OperateFn represents operations that require decoration
ऑपरेटFn func टाइप करें ()
type OperateFn func()


// ऑपरेशन को सजाएं
//Decorate the operation
func डेकोरेट (opFn ऑपरेटFn) {
func Decorate(opFn OperateFn) {
defer func (समय। समय) {
defer func(s time.Time) {
log.Printf(बीता हुआ समय %0.2d एमएस , time.Since(s).Nanoseconds() / 1000000)
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
"github.com/tkstorm/go-design/structural/decorator/decolog"
लकड़ी का लट्ठा
"log"
गणित/रैंड
"math/rand"
समय
"time"
)
)


// आउटपुट:
//output:
//2019/08/19 19:05:24 समाप्त कार्रवाई ए
//2019/08/19 19:05:24 finish action a
//2019/08/19 19:05:24 बीता हुआ समय 77 एमएस
//2019/08/19 19:05:24 elapsed time 77 ms
//2019/08/19 19:05:24 समाप्त कार्रवाई ख
//2019/08/19 19:05:24 finish action b
//2019/08/19 19:05:24 बीता हुआ समय 88 एमएस
//2019/08/19 19:05:24 elapsed time 88 ms
फंक मेन () {
func main() {
// सजावटी लॉग ए
// decorate log a
decolog.Decorate (decolog.OperateFn (DoActionA))
decolog.Decorate(decolog.OperateFn(DoActionA))
// सजावटी लॉग बी
// decorate log b
decolog.Decorate (decolog.OperateFn (DoActionB))
decolog.Decorate(decolog.OperateFn(DoActionB))
}
}


func DoActionA () {
func DoActionA() {
समय। नींद (समय। अवधि (रैंड। इंटन (200)) * समय। मिलीसेकंड)
time.Sleep(time.Duration(rand.Intn(200)) * time.Millisecond)
log.Println (कार्रवाई समाप्त करें ए)
log.Println("finish action a")
}
}


func DoActionB () {
func DoActionB() {
समय। नींद (समय। अवधि (रैंड। इंटन (200)) * समय। मिलीसेकंड)
time.Sleep(time.Duration(rand.Intn(200)) * time.Millisecond)
log.Println (कार्रवाई ख समाप्त करें)
log.Println("finish action b")
}
}
</वाक्यविन्यास हाइलाइट>
</syntaxhighlight>


=== सी ++ ===
=== सी ++ ===
Line 165: Line 164:


==== डायनेमिक डेकोरेटर ====
==== डायनेमिक डेकोरेटर ====
<वाक्यविन्यास लैंग = सीपीपी>
<syntaxhighlight lang="d">
#शामिल <iostream>
#include <iostream>
#शामिल <स्ट्रिंग>
#include <string>


संरचना आकार {
struct Shape {
   आभासी ~ आकार () = डिफ़ॉल्ट;
   virtual ~Shape() = default;


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


संरचना वृत्त : आकार {
struct Circle : Shape {
   शून्य आकार (फ्लोट कारक) {त्रिज्या * = कारक; }
   void Resize(float factor) { radius *= factor; }


   एसटीडी :: स्ट्रिंग GetName () कास्ट अधिभावी {
   std::string GetName() const override {
     वापसी एसटीडी�:: स्ट्रिंग (त्रिज्या का एक चक्र) + एसटीडी�:: to_string (त्रिज्या);
     return std::string("A circle of radius ") + std::to_string(radius);
   }
   }


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


संरचना रंगीन आकार : आकार {
struct ColoredShape : Shape {
   ColoredShape (स्थिरांक एसटीडी :: स्ट्रिंग और रंग, आकार * आकार)
   ColoredShape(const std::string& color, Shape* shape)
       : रंग (रंग), आकार (आकार) {}
       : color(color), shape(shape) {}


   एसटीडी :: स्ट्रिंग GetName () कास्ट अधिभावी {
   std::string GetName() const override {
     वापसी का आकार-> GetName () + जो रंगीन + रंग है;
     return shape->GetName() + " which is colored " + color;
   }
   }


   एसटीडी :: स्ट्रिंग रंग;
   std::string color;
   आकार * आकार;
   Shape* shape;
};
};


मुख्य प्रवेश बिंदु() {
int main() {
   सर्किल सर्कल;
   Circle circle;
   रंगीन आकार रंगीन_आकार (लाल, और सर्कल);
   ColoredShape colored_shape("red", &circle);
   एसटीडी :: अदालत << color_shape.GetName () << एसटीडी :: endl;
   std::cout << colored_shape.GetName() << std::endl;


}
}
</वाक्यविन्यास हाइलाइट>
#include <memory>
<वाक्यविन्यास लैंग = सीपीपी>
#include <iostream>
 
#include <string>
#शामिल <मेमोरी>
#शामिल <iostream>
#शामिल <स्ट्रिंग>


स्ट्रक्चर वेबपेज
struct WebPage
{
{
     आभासी शून्य प्रदर्शन () = 0;
     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))
     WebPageDecorator(std::unique_ptr<WebPage> webPage): _webPage(std::move(webPage))
     {
     {
     }
     }
     शून्य प्रदर्शन () अधिभावी
     void display() override
     {
     {
         _वेबपेज-> डिस्प्ले ();
         _webPage->display();
     }
     }
निजी:
private:
     एसटीडी :: Unique_ptr <वेबपेज> _webPage;
     std::unique_ptr<WebPage> _webPage;
};
};


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


     शून्य प्रमाणीकरण उपयोगकर्ता ()
     void authenticateUser()
     {
     {
         एसटीडी�:: अदालत << प्रमाणीकरण किया << एसटीडी�:: endl;
         std::cout << "authentification done" << std::endl;
     }
     }
     शून्य प्रदर्शन () अधिभावी
     void display() override
     {
     {
         प्रमाणित उपयोगकर्ता ();
         authenticateUser();
         वेबपेजडेकोरेटर�:: प्रदर्शन ();
         WebPageDecorator::display();
     }
     }
};
};


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


     शून्य प्राधिकृत उपयोगकर्ता ()
     void authorizedUser()
     {
     {
         std::cout << अधिकृत किया << std::endl;
         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>();
     std::unique_ptr<WebPage> myPage = std::make_unique<BasicWebPage>();


     myPage = std::make_unique<AuthorizedWebPage>(std::move(myPage));
     myPage = std::make_unique<AuthorizedWebPage>(std::move(myPage));
     myPage = std::make_unique<AuthenticatedWebPage>(std::move(myPage));
     myPage = std::make_unique<AuthenticatedWebPage>(std::move(myPage));
     मायपेज-> डिस्प्ले ();
     myPage->display();
     एसटीडी :: अदालत << एसटीडी :: endl;
     std::cout << std::endl;
     वापसी 0;
     return 0;
}
}
 
</syntaxhighlight>
</वाक्यविन्यास हाइलाइट>


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


यह उदाहरण एक स्थिर डेकोरेटर कार्यान्वयन को प्रदर्शित करता है, जो टेम्पलेट तर्क से इनहेरिट करने की C++ क्षमता के कारण संभव है।
यह उदाहरण एक स्थिर डेकोरेटर कार्यान्वयन को प्रदर्शित करता है, जो टेम्पलेट तर्क से इनहेरिट करने की C++ क्षमता के कारण संभव है।<syntaxhighlight lang="d">
#include <iostream>
#include <string>


<वाक्यविन्यास लैंग = सीपीपी>
struct Circle {
#शामिल <iostream>
  void Resize(float factor) { radius *= factor; }
#शामिल <स्ट्रिंग>


संरचना सर्किल {
   std::string GetName() const {
  शून्य आकार (फ्लोट कारक) {त्रिज्या * = कारक; }
     return std::string("A circle of radius ") + std::to_string(radius);
 
   एसटीडी :: स्ट्रिंग GetName () कास्ट {
     वापसी एसटीडी :: स्ट्रिंग (त्रिज्या का एक चक्र) + एसटीडी :: to_string (त्रिज्या);
   }
   }


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


टेम्पलेट <टाइपनाम टी>
template <typename T>
संरचना रंगीन आकार: सार्वजनिक टी {
struct ColoredShape : public T {
   रंगीन आकार (स्थिरांक एसटीडी :: स्ट्रिंग और रंग): रंग (रंग) {}
   ColoredShape(const std::string& color) : color(color) {}


   एसटीडी :: स्ट्रिंग GetName () कास्ट {
   std::string GetName() const {
     वापसी टी :: GetName () + जो रंगीन + रंग है;
     return T::GetName() + " which is colored " + color;
   }
   }


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


मुख्य प्रवेश बिंदु() {
int main() {
   ColoredShape<Circle> red_circle( red );
   ColoredShape<Circle> red_circle("red");
   एसटीडी :: अदालत << red_circle.GetName () << एसटीडी :: endl;
   std::cout << red_circle.GetName() << std::endl;
   red_circle.Resize (1.5f);
   red_circle.Resize(1.5f);
   एसटीडी :: अदालत << red_circle.GetName () << एसटीडी :: endl;
   std::cout << red_circle.GetName() << std::endl;
}
}
 
</syntaxhighlight>
</वाक्यविन्यास हाइलाइट>


=== जावा ===
=== जावा ===


==== पहला उदाहरण (विंडो/स्क्रॉलिंग परिदृश्य) ====
==== पहला उदाहरण (विंडो/स्क्रॉलिंग परिदृश्य) ====
निम्न जावा उदाहरण विंडो/स्क्रॉलिंग परिदृश्य का उपयोग कर सजावटी के उपयोग को दिखाता है।
निम्न जावा उदाहरण विंडो/स्क्रॉलिंग परिदृश्य का उपयोग कर सजावटी के उपयोग को दिखाता है।<syntaxhighlight lang="d">
{{Clear}}
// The Window interface class
<वाक्यविन्यास प्रकाश लैंग = जावा>
public interface Window {
// विंडो इंटरफ़ेस वर्ग
     void draw(); // Draws the Window
सार्वजनिक इंटरफ़ेस विंडो {
     String getDescription(); // Returns a description of the Window
     शून्य ड्रा (); // विंडो ड्रा करें
     स्ट्रिंग getDescription (); // विंडो का विवरण लौटाता है
}
}


// बिना किसी स्क्रॉलबार के एक साधारण विंडो का कार्यान्वयन
// Implementation of a simple Window without any scrollbars
वर्ग सिंपलविंडो विंडो लागू करता है {
class SimpleWindow implements Window {
     @Override
     @Override
     सार्वजनिक शून्य ड्रा () {
     public void draw() {
         // विंडो ड्रा करें
         // Draw window
     }
     }
     @Override
     @Override
     सार्वजनिक स्ट्रिंग getDescription () {
     public String getDescription() {
         साधारण खिड़की लौटें;
         return "simple window";
     }
     }
}
}
</वाक्यविन्यास हाइलाइट>
</syntaxhighlight>निम्नलिखित वर्गों में सभी के लिए डेकोरेटर हैं <code>Window</code> कक्षाएं, डेकोरेटर कक्षाओं सहित स्वयं।<syntaxhighlight lang="d">
 
// abstract decorator class - note that it implements Window
निम्नलिखित वर्गों में सभी के लिए डेकोरेटर हैं <code>Window</code> कक्षाएं, डेकोरेटर कक्षाओं सहित स्वयं।
abstract class WindowDecorator implements Window {
 
     private final Window windowToBeDecorated; // the Window being decorated
<वाक्यविन्यास प्रकाश लैंग = जावा>
// अमूर्त डेकोरेटर वर्ग - ध्यान दें कि यह विंडो को लागू करता है
सार वर्ग WindowDecorator विंडो लागू करता है {
     निजी अंतिम विंडो विंडो को सजाने के लिए; // खिड़की को सजाया जा रहा है


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


// पहला कंक्रीट डेकोरेटर जो लंबवत स्क्रॉलबार कार्यक्षमता जोड़ता है
// The first concrete decorator which adds vertical scrollbar functionality
वर्ग VerticalScrollBarDecorator WindowDecorator का विस्तार करता है {
class VerticalScrollBarDecorator extends WindowDecorator {
     सार्वजनिक वर्टिकलस्क्रॉलबार डेकोरेटर (विंडो विंडोटूबीडेकोरेट) {
     public VerticalScrollBarDecorator (Window windowToBeDecorated) {
         सुपर (windowToBeDecorated);
         super(windowToBeDecorated);
     }
     }


     @Override
     @Override
     सार्वजनिक शून्य ड्रा () {
     public void draw() {
         सुपर ड्रा ();
         super.draw();
         ड्रा वर्टिकलस्क्रॉलबार ();
         drawVerticalScrollBar();
     }
     }


     निजी शून्य ड्रा वर्टिकलस्क्रॉलबार () {
     private void drawVerticalScrollBar() {
         // वर्टिकल स्क्रॉलबार ड्रा करें
         // Draw the vertical scrollbar
     }
     }


     @Override
     @Override
     सार्वजनिक स्ट्रिंग getDescription () {
     public String getDescription() {
         वापसी super.getDescription() + , लंबवत स्क्रॉलबार सहित;
         return super.getDescription() + ", including vertical scrollbars";
     }
     }
}
}


// दूसरा कंक्रीट डेकोरेटर जो क्षैतिज स्क्रॉलबार कार्यक्षमता जोड़ता है
// The second concrete decorator which adds horizontal scrollbar functionality
वर्ग हॉरिज़ॉन्टलस्क्रॉलबारडेकोरेटर विंडोडेकोरेटर का विस्तार करता है {
class HorizontalScrollBarDecorator extends WindowDecorator {
     सार्वजनिक क्षैतिज स्क्रॉलबार डिकोरेटर (विंडो विंडो टूबी डेकोरेटेड) {
     public HorizontalScrollBarDecorator (Window windowToBeDecorated) {
         सुपर (windowToBeDecorated);
         super(windowToBeDecorated);
     }
     }


     @Override
     @Override
     सार्वजनिक शून्य ड्रा () {
     public void draw() {
         सुपर ड्रा ();
         super.draw();
         DrawHorizontalScrollBar();
         drawHorizontalScrollBar();
     }
     }


     निजी शून्य ड्रा क्षैतिज स्क्रॉलबार () {
     private void drawHorizontalScrollBar() {
         // क्षैतिज स्क्रॉलबार ड्रा करें
         // Draw the horizontal scrollbar
     }
     }


     @Override
     @Override
     सार्वजनिक स्ट्रिंग getDescription () {
     public String getDescription() {
         वापसी super.getDescription() +, क्षैतिज स्क्रॉलबार सहित;
         return super.getDescription() + ", including horizontal scrollbars";
     }
     }
}
}
</वाक्यविन्यास हाइलाइट>
</syntaxhighlight>यहां एक टेस्ट प्रोग्राम है जो एक बनाता है <code>Window</code> उदाहरण जो पूरी तरह से सजाया गया है (यानी, लंबवत और क्षैतिज स्क्रॉलबार के साथ), और इसका विवरण प्रिंट करता है:<syntaxhighlight lang="d">
 
public class DecoratedWindowTest {
यहां एक टेस्ट प्रोग्राम है जो एक बनाता है <code>Window</code> उदाहरण जो पूरी तरह से सजाया गया है (यानी, लंबवत और क्षैतिज स्क्रॉलबार के साथ), और इसका विवरण प्रिंट करता है:
     public static void main(String[] args) {
 
         // Create a decorated Window with horizontal and vertical scrollbars
<वाक्यविन्यास प्रकाश लैंग = जावा>
         Window decoratedWindow = new HorizontalScrollBarDecorator (
पब्लिक वर्ग डेकोरेटेड विन्डोटेस्ट {
                 new VerticalScrollBarDecorator (new SimpleWindow()));
     सार्वजनिक स्थैतिक शून्य main (String [] args) {
         // क्षैतिज और लंबवत स्क्रॉलबार के साथ एक सजाया हुआ विंडो बनाएं
         विंडो डेकोरेटेडविंडो = नया हॉरिजॉन्टलस्क्रॉलबारडेकोरेटर (
                 नया वर्टिकलस्क्रॉलबार डेकोरेटर (नया सिंपलविंडो ()));


         // विंडो का विवरण प्रिंट करें
         // Print the Window's description
         System.out.println (सजाया गयाWindow.getDescription ());
         System.out.println(decoratedWindow.getDescription());
     }
     }
}
}
</वाक्यविन्यास हाइलाइट>
</syntaxhighlight>इस प्रोग्राम का आउटपुट सिंपल विंडो है, जिसमें वर्टिकल स्क्रॉलबार, हॉरिजॉन्टल स्क्रॉलबार शामिल हैं। ध्यान दें कि कैसे <code>getDescription</code> दो डेकोरेटरों की विधि पहले सजाए गए को पुनः प्राप्त करती है <code>Window</code>का वर्णन करता है और उसे प्रत्यय से अलंकृत करता है।


इस प्रोग्राम का आउटपुट सिंपल विंडो है, जिसमें वर्टिकल स्क्रॉलबार, हॉरिजॉन्टल स्क्रॉलबार शामिल हैं। ध्यान दें कि कैसे <code>getDescription</code> दो डेकोरेटरों की विधि पहले सजाए गए को पुनः प्राप्त करती है <code>Window</code>का वर्णन करता है और उसे प्रत्यय से अलंकृत करता है।
नीचे टेस्ट ड्रिवेन डेवलपमेंट के लिए JUnit टेस्ट वर्ग है<syntaxhighlight lang="d">
import static org.junit.Assert.assertEquals;


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


आयात 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());
      // दावा करें कि विवरण में वास्तव में क्षैतिज + लंबवत स्क्रॉलबार शामिल हैं
}
             AssertEquals (सरल विंडो, वर्टिकल स्क्रॉलबार सहित, हॉरिजॉन्टल स्क्रॉलबार सहित, डेकोरेटेड विन्डो.गेटडिस्क्रिप्शन ());
}
}
}
</syntaxhighlight>


</वाक्यविन्यास हाइलाइट>
==== दूसरा उदाहरण (कॉफी बनाने का परिदृश्य) asasasasa ====
 
==== दूसरा उदाहरण (कॉफी बनाने का परिदृश्य) ====
अगला जावा उदाहरण कॉफी बनाने के परिदृश्य का उपयोग करते हुए डेकोरेटरों के उपयोग को दिखाता है।
अगला जावा उदाहरण कॉफी बनाने के परिदृश्य का उपयोग करते हुए डेकोरेटरों के उपयोग को दिखाता है।
इस उदाहरण में, परिदृश्य में केवल लागत और सामग्री शामिल हैं।
इस उदाहरण में, परिदृश्य में केवल लागत और सामग्री शामिल हैं।
{{Clear}}
 
<वाक्यविन्यास प्रकाश लैंग = जावा>
<वाक्यविन्यास प्रकाश लैंग = जावा>
// इंटरफ़ेस कॉफी डेकोरेटर द्वारा कार्यान्वित कॉफी की कार्यक्षमता को परिभाषित करता है
// इंटरफ़ेस कॉफी डेकोरेटर द्वारा कार्यान्वित कॉफी की कार्यक्षमता को परिभाषित करता है

Revision as of 16:03, 18 February 2023

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’