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

From Vigyanwiki
No edit summary
No edit summary
Line 425: Line 425:
</syntaxhighlight>
</syntaxhighlight>


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


<वाक्यविन्यास प्रकाश लैंग = जावा>
इस उदाहरण में, परिदृश्य में केवल लागत और सामग्री शामिल हैं।<syntaxhighlight lang="d">
// इंटरफ़ेस कॉफी डेकोरेटर द्वारा कार्यान्वित कॉफी की कार्यक्षमता को परिभाषित करता है
// The interface Coffee defines the functionality of Coffee implemented by decorator
सार्वजनिक इंटरफ़ेस कॉफ़ी {
public interface Coffee {
     सार्वजनिक डबल गेटकॉस्ट (); // कॉफी की लागत लौटाता है
     public double getCost(); // Returns the cost of the coffee
     सार्वजनिक स्ट्रिंग getIngredients (); // कॉफी की सामग्री लौटाता है
     public String getIngredients(); // Returns the ingredients of the coffee
}
}


// बिना किसी अतिरिक्त सामग्री के एक साधारण कॉफी का विस्तार
// Extension of a simple coffee without any extra ingredients
पब्लिक वर्ग सिंपलकॉफी कॉफी लागू करता है {
public class SimpleCoffee implements Coffee {
     @Override
     @Override
     सार्वजनिक डबल गेटकॉस्ट () {
     public double getCost() {
         वापसी 1;
         return 1;
     }
     }


     @Override
     @Override
     सार्वजनिक स्ट्रिंग getIngredients () {
     public String getIngredients() {
         वापसी कॉफी;
         return "Coffee";
     }
     }
}
}
</वाक्यविन्यास हाइलाइट>
</syntaxhighlight>निम्नलिखित वर्गों में सभी के लिए डेकोरेटर हैं {{mono|Coffee}} कक्षाएं, डेकोरेटर कक्षाओं सहित स्वयं।<syntaxhighlight lang="d">
// Abstract decorator class - note that it implements Coffee interface
public abstract class CoffeeDecorator implements Coffee {
    private final Coffee decoratedCoffee;


निम्नलिखित वर्गों में सभी के लिए डेकोरेटर हैं {{mono|Coffee}} कक्षाएं, डेकोरेटर कक्षाओं सहित स्वयं।
     public CoffeeDecorator(Coffee c) {
 
<वाक्यविन्यास प्रकाश लैंग = जावा>
 
// एब्सट्रैक्ट डेकोरेटर वर्ग - ध्यान दें कि यह कॉफी इंटरफ़ेस को लागू करता है
सार्वजनिक सार वर्ग कॉफीडेकोरेटर कॉफी को लागू करता है {
     निजी अंतिम कॉफी सजाया कॉफी;
 
    सार्वजनिक कॉफीडेकोरेटर (कॉफी सी) {
         this.decoratedCoffee = c;
         this.decoratedCoffee = c;
     }
     }


     @Override
     @Override
     सार्वजनिक डबल गेटकॉस्ट () {// इंटरफ़ेस के कार्यान्वयन के तरीके
     public double getCost() { // Implementing methods of the interface
         सजी हुई कॉफी लौटाएं। getCost ();
         return decoratedCoffee.getCost();
     }
     }


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


// डेकोरेटर विथ मिल्क कॉफी में दूध मिलाता है।
// Decorator WithMilk mixes milk into coffee.
// ध्यान दें कि यह CoffeeDecorator का विस्तार करता है।
// Note it extends CoffeeDecorator.
वर्ग WithMilk कॉफीडेकोरेटर का विस्तार करता है {
class WithMilk extends CoffeeDecorator {
     सार्वजनिक दूध के साथ (कॉफी सी) {
     public WithMilk(Coffee c) {
         सुपर (सी);
         super(c);
     }
     }


     @Override
     @Override
     सार्वजनिक डबल गेटकॉस्ट () {// अमूर्त सुपरवर्ग में परिभाषित विधियों को अधिभावी करना
     public double getCost() { // Overriding methods defined in the abstract superclass
         रिटर्न सुपर.गेटकॉस्ट () + 0.5;
         return super.getCost() + 0.5;
     }
     }


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


// डेकोरेटर विथस्प्रिंकल्स कॉफ़ी पर स्प्रिंकल्स को मिलाता है।
// Decorator WithSprinkles mixes sprinkles onto coffee.
// ध्यान दें कि यह CoffeeDecorator का विस्तार करता है।
// Note it extends CoffeeDecorator.
वर्ग WithSprinkles CoffeeDecorator { का विस्तार करता है
class WithSprinkles extends CoffeeDecorator {
     पब्लिक विदस्प्रिंकल्स (कॉफी सी) {
     public WithSprinkles(Coffee c) {
         सुपर (सी);
         super(c);
     }
     }


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


     @Override
     @Override
     सार्वजनिक स्ट्रिंग getIngredients () {
     public String getIngredients() {
         रिटर्न सुपर.गेटइन्ग्रेडिएंट्स () +, स्प्रिंकल्स;
         return super.getIngredients() + ", Sprinkles";
     }
     }
}
}
</वाक्यविन्यास हाइलाइट>
</syntaxhighlight>यहां एक टेस्ट प्रोग्राम है जो एक बनाता है {{mono|Coffee}} उदाहरण जो पूरी तरह से सजाया गया है (दूध और स्प्रिंकल्स के साथ), और कॉफी की लागत की गणना करता है और इसकी सामग्री को प्रिंट करता है:<syntaxhighlight lang="d">
 
public class Main {
यहां एक टेस्ट प्रोग्राम है जो एक बनाता है {{mono|Coffee}} उदाहरण जो पूरी तरह से सजाया गया है (दूध और स्प्रिंकल्स के साथ), और कॉफी की लागत की गणना करता है और इसकी सामग्री को प्रिंट करता है:
     public static void printInfo(Coffee c) {
 
         System.out.println("Cost: " + c.getCost() + "; Ingredients: " + c.getIngredients());
<वाक्यविन्यास प्रकाश लैंग = जावा>
सार्वजनिक वर्ग मुख्य {
     सार्वजनिक स्थैतिक शून्य प्रिंटइन्फो (कॉफी सी) {
         System.out.println (लागत: + c.getCost () +; सामग्री: + c.getIngredients ());
     }
     }


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


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


         सी = नया विथस्प्रिंकल्स (सी);
         c = new WithSprinkles(c);
         प्रिंटइन्फो (सी);
         printInfo(c);
     }
     }
}
}
</वाक्यविन्यास हाइलाइट>
</syntaxhighlight>इस कार्यक्रम का आउटपुट नीचे दिया गया है:<syntaxhighlight lang="d">
 
Cost: 1.0; Ingredients: Coffee
इस कार्यक्रम का आउटपुट नीचे दिया गया है:
Cost: 1.5; Ingredients: Coffee, Milk
<पूर्व>
Cost: 1.7; Ingredients: Coffee, Milk, Sprinkles
लागत: 1.0; सामग्री: कॉफी
</syntaxhighlight>
लागत: 1.5; सामग्री: कॉफी, दूध
लागत: 1.7; सामग्री: कॉफी, दूध, स्प्रिंकल्स
</पूर्व>


=== पीएचपी ===
=== पीएचपी ===
<वाक्यविन्यास लैंग = php>
<syntaxhighlight lang="d">
सार वर्ग घटक
abstract class Component
{
{
     संरक्षित $ डेटा;
     protected $data;
     संरक्षित $ मूल्य;
     protected $value;


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


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


वर्ग कंक्रीटघटक घटक का विस्तार करता है
class ConcreteComponent extends Component
{
{
     सार्वजनिक समारोह __ निर्माण ()
     public function __construct()
     {
     {
         $ यह-> मूल्य = 1000;
         $this->value = 1000;
         $this->data = कंक्रीट घटक:\t{$this->value}\n};
         $this->data = "Concrete Component:\t{$this->value}\n";
     }
     }


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


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


सार वर्ग डेकोरेटर घटक का विस्तार करता है
abstract class Decorator extends Component
{
{
      
      
}
}


वर्ग ConcreteDecorator1 डेकोरेटर का विस्तार करता है
class ConcreteDecorator1 extends Decorator
{
{
     सार्वजनिक कार्य __ निर्माण (घटक $ डेटा)
     public function __construct(Component $data)
     {
     {
         $ यह-> मूल्य = 500;
         $this->value = 500;
         $ यह-> डेटा = $ डेटा;
         $this->data = $data;
     }
     }


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


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


वर्ग ConcreteDecorator2 डेकोरेटर का विस्तार करता है
class ConcreteDecorator2 extends Decorator
{
{
     सार्वजनिक कार्य __ निर्माण (घटक $ डेटा)
     public function __construct(Component $data)
     {
     {
         $ यह-> मूल्य = 500;
         $this->value = 500;
         $ यह-> डेटा = $ डेटा;
         $this->data = $data;
     }
     }


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


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


वर्ग क्लाइंट
class Client
{
{
     निजी $ घटक;
     private $component;


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


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


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


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


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


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


=== पायथन ===
=== पायथन ===


निम्नलिखित पायथन उदाहरण, [https://wiki.python.org/moin/DecoratorPattern Python Wiki - डेकोरेटरपैटर्न] से लिया गया है, हमें दिखाता है कि किसी वस्तु में गतिशील रूप से कई व्यवहारों को जोड़ने के लिए पाइपलाइन डेकोरेटर्स कैसे करें:
निम्नलिखित पायथन उदाहरण, [https://wiki.python.org/moin/DecoratorPattern Python Wiki - डेकोरेटरपैटर्न] से लिया गया है, हमें दिखाता है कि किसी वस्तु में गतिशील रूप से कई व्यवहारों को जोड़ने के लिए पाइपलाइन डेकोरेटर्स कैसे करें:<syntaxhighlight lang="d">
"""
Demonstrated decorators in a world of a 10x10 grid of values 0-255.
"""


<वाक्यविन्यास लैंग = अजगर>
import random
 
0-255 मानों के 10x10 ग्रिड की दुनिया में प्रदर्शित डेकोरेटर।
 
 
यादृच्छिक आयात करें




def s32_to_u16(x):
def s32_to_u16(x):
     अगर एक्स <0:
     if x < 0:
         साइन = 0xF000
         sign = 0xF000
     अन्य:
     else:
         चिह्न = 0
         sign = 0
     नीचे = एक्स और 0x00007FFF
     bottom = x & 0x00007FFF
     नीचे लौटें | संकेत
     return bottom | sign




डीईएफ़ Seed_from_xy (एक्स, वाई):
def seed_from_xy(x, y):
     वापसी s32_to_u16(x) | (S32_to_u16(y) << 16)
     return s32_to_u16(x) | (s32_to_u16(y) << 16)




वर्ग रैंडम स्क्वायर:
class RandomSquare:
     डीईएफ़ __init__(s, Seed_modifier):
     def __init__(s, seed_modifier):
         s.seed_modifier = Seed_modifier
         s.seed_modifier = seed_modifier


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




वर्ग डेटा स्क्वायर:
class DataSquare:
     def __init__(s, initial_value=कोई नहीं):
     def __init__(s, initial_value=None):
         s.data = [प्रारंभिक_मूल्य] * 10 * 10
         s.data = [initial_value] * 10 * 10


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


     डीईएफ़ सेट (एस, एक्स, वाई, यू):
     def set(s, x, y, u):
         एस डेटा [(वाई * 10) + एक्स] = यू
         s.data[(y * 10) + x] = u




वर्ग कैशडेकोरेटर:
class CacheDecorator:
     def __init__(s, सजाया गया):
     def __init__(s, decorated):
         स.सज्जित = सुशोभित
         s.decorated = decorated
         s.cache = DataSquare ()
         s.cache = DataSquare()


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




वर्ग मैक्सडेकोरेटर:
class MaxDecorator:
     def __init__(s, सजाया गया, अधिकतम):
     def __init__(s, decorated, max):
         स.सज्जित = सुशोभित
         s.decorated = decorated
         s.max = मैक्स
         s.max = max


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




वर्ग मिनडेकोरेटर:
class MinDecorator:
     डीईएफ़ __init__(एस, सजाया, न्यूनतम):
     def __init__(s, decorated, min):
         स.सज्जित = सुशोभित
         s.decorated = decorated
         मिनट = मिनट
         s.min = min


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




वर्ग दृश्यता डेकोरेटर:
class VisibilityDecorator:
     def __init__(s, सजाया गया):
     def __init__(s, decorated):
         स.सज्जित = सुशोभित
         s.decorated = decorated


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


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




# अब, डेकोरेटर्स की एक पाइपलाइन बनाएं:
# Now, build up a pipeline of decorators:


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


अंतिम ड्रा ()
final.draw()
</वाक्यविन्यास हाइलाइट>
</syntaxhighlight>'''टिप्पणी''':


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


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


<blockquote>डेकोरेटर पैटर्न डिजाइन पैटर्न बुक में वर्णित एक पैटर्न है। यह एक वस्तु के व्यवहार को स्पष्ट रूप से संशोधित करने का एक तरीका है, इसे एक समान इंटरफ़ेस के साथ एक सजावटी वस्तु के अंदर संलग्न करके।
<blockquote>डेकोरेटर पैटर्न डिजाइन पैटर्न बुक में वर्णित एक पैटर्न है। यह एक वस्तु के व्यवहार को स्पष्ट रूप से संशोधित करने का एक तरीका है, इसे एक समान इंटरफ़ेस के साथ एक सजावटी वस्तु के अंदर संलग्न करके।
यह पायथन डेकोरेटर्स के साथ भ्रमित नहीं होना है, जो किसी कार्य या वर्ग को गतिशील रूप से संशोधित करने के लिए एक भाषा सुविधा है।<ref>{{cite web|url=https://wiki.python.org/moin/DecoratorPattern|title=DecoratorPattern - Python Wiki|website=wiki.python.org}}</ref></ब्लॉककोट>
यह पायथन डेकोरेटर्स के साथ भ्रमित नहीं होना है, जो किसी कार्य या वर्ग को गतिशील रूप से संशोधित करने के लिए एक भाषा सुविधा है।<ref>{{cite web|url=https://wiki.python.org/moin/DecoratorPattern|title=DecoratorPattern - Python Wiki|website=wiki.python.org}}</ref>


=== क्रिस्टल ===
=== क्रिस्टल ===
<वाक्यविन्यास लैंग = रूबी>
<syntaxhighlight lang="d">
सार वर्ग कॉफी
abstract class Coffee
   सार डीईएफ़ लागत
   abstract def cost
   सार def सामग्री
   abstract def ingredients
अंत
end


# एक साधारण कॉफी का विस्तार
# Extension of a simple coffee
वर्ग सिंपलकॉफ़ी <कॉफ़ी
class SimpleCoffee < Coffee
   डीईएफ़ लागत
   def cost
     1.0
     1.0
   अंत
   end


   डीईएफ़ सामग्री
   def ingredients
    कॉफ़ी
    "Coffee"
   अंत
   end
अंत
end


# सार डेकोरेटर
# Abstract decorator
वर्ग कॉफीडेकोरेटर <कॉफी
class CoffeeDecorator < Coffee
   संरक्षित गेट्टर डेकोरेटेड_कॉफ़ी : कॉफ़ी
   protected getter decorated_coffee : Coffee


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


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


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


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


   डीईएफ़ सामग्री
   def ingredients
     सुपर +, दूध
     super + ", Milk"
   अंत
   end
अंत
end


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


   डीईएफ़ सामग्री
   def ingredients
     सुपर +, स्प्रिंकल्स
     super + ", Sprinkles"
   अंत
   end
अंत
end


वर्ग कार्यक्रम
class Program
   डेफ प्रिंट (कॉफी: कॉफी)
   def print(coffee : Coffee)
     लागत डालता है: #{coffee.cost}; सामग्री: #{coffee.ingredients}
     puts "Cost: #{coffee.cost}; Ingredients: #{coffee.ingredients}"
   अंत
   end


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


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


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


प्रोग्राम.नया
Program.new
</वाक्यविन्यास हाइलाइट>
</syntaxhighlight>'''आउटपुट''':<syntaxhighlight lang="d">
 
Cost: 1.0; Ingredients: Coffee
आउटपुट:
Cost: 1.5; Ingredients: Coffee, Milk
<पूर्व>
Cost: 1.7; Ingredients: Coffee, Milk, Sprinkles
लागत: 1.0; सामग्री: कॉफी
</syntaxhighlight>
लागत: 1.5; सामग्री: कॉफी, दूध
लागत: 1.7; सामग्री: कॉफी, दूध, स्प्रिंकल्स
</पूर्व>


===सी#===
===सी#===
<syntaxhighlight>
namespace WikiDesignPatterns;


<वाक्यविन्यास प्रकाश लैंग = csharp>
public interface IBike
नेमस्पेस विकीडिजाइनपैटर्न;
 
सार्वजनिक इंटरफ़ेस IBike
{
{
     स्ट्रिंग GetDetails ();
     string GetDetails();
     डबल गेटप्राइस ();
     double GetPrice();
}
}


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


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


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


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




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


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


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




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


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


     }
     }


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


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


पब्लिक वर्ग स्पोर्टपैकेज: बाइक एक्सेसरीज
public class SportPackage : BikeAccessories
{
{
     सार्वजनिक स्पोर्टपैकेज (आईबाइक बाइक): आधार (बाइक)
     public SportPackage(IBike bike) : base(bike)
     {
     {


     }
     }


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


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


पब्लिक वर्ग बाइकशॉप
public class BikeShop
{
{
     सार्वजनिक स्थैतिक शून्य अपग्रेडबाइक ()
     public static void UpgradeBike()
     {
     {
         var आधारिकबाइक = नया एल्युमिनियमबाइक ();
         var basicBike = new AluminiumBike();
         बाइक का सामान अपग्रेड किया गया = नया स्पोर्टपैकेज (आधारिकबाइक);
         BikeAccessories upgraded = new SportPackage(basicBike);
         उन्नत = नया सुरक्षा पैकेज (उन्नत);
         upgraded = new SecurityPackage(upgraded);


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


     }
     }
}
}
</वाक्यविन्यास हाइलाइट>
</syntaxhighlight>'''आउटपुट:'''<syntaxhighlight lang="d">
 
Bike: 'Aluminium Bike + Sport Package + Security Package' Cost: 111
आउटपुट:
</syntaxhighlight>
<पूर्व>
बाइक: 'एल्युमीनियम बाइक + स्पोर्ट पैकेज + सुरक्षा पैकेज' कीमत: 111
</पूर्व>


=== रूबी ===
=== रूबी ===
<वाक्यविन्यास लैंग = रूबी>
<syntaxhighlight lang="d">
वर्ग एब्स्ट्रैक्टकॉफ़ी
class AbstractCoffee
   डेफ प्रिंट
   def print
     डालता लागत: #{लागत}; सामग्री: #{सामग्री}
     puts "Cost: #{cost}; Ingredients: #{ingredients}"
   अंत
   end
अंत
end


वर्ग सिंपलकॉफ़ी <एब्स्ट्रैक्टकॉफ़ी
class SimpleCoffee < AbstractCoffee
   डीईएफ़ लागत
   def cost
     1.0
     1.0
   अंत
   end
 
  डीईएफ़ सामग्री
    कॉफ़ी
  अंत
अंत
 
वर्ग दूध के साथ <सरल डिलीगेटर
  डीईएफ़ लागत
    __getobj__.लागत + 0.5
  अंत


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


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


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


कॉफ़ी = सिंपलकॉफ़ी.नया
class WithSprinkles < SimpleDelegator
कॉफी प्रिंट
  def cost
    __getobj__.cost + 0.2
  end


कॉफी = दूध के साथ। नया (कॉफी)
  def ingredients
कॉफी प्रिंट
    __getobj__.ingredients + ", Sprinkles"
  end
end


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


</वाक्यविन्यास हाइलाइट>
coffee = WithMilk.new(coffee)
coffee.print


coffee = WithSprinkles.new(coffee)
coffee.print


आउटपुट:
</syntaxhighlight>
<पूर्व>
'''आउटपुट:'''<syntaxhighlight lang="d">
लागत: 1.0; सामग्री: कॉफी
Cost: 1.0; Ingredients: Coffee
लागत: 1.5; सामग्री: कॉफी, दूध
Cost: 1.5; Ingredients: Coffee, Milk
लागत: 1.7; सामग्री: कॉफी, दूध, स्प्रिंकल्स
Cost: 1.7; Ingredients: Coffee, Milk, Sprinkles
</पूर्व>
</syntaxhighlight>


== यह भी देखें ==
== यह भी देखें ==

Revision as of 18:07, 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());
	}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

पीएचपी

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

    abstract public function getData();

    abstract public function getValue();
}

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

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

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

abstract class Decorator extends Component
{
    
}

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

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

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

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

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

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

class Client
{
    private $component;

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

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

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

$client = new Client();

// Result: #quanton81

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

पायथन

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

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

import random


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


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


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

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


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

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

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


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

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


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

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


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

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


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

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

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


# Now, build up a pipeline of decorators:

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

final.draw()

टिप्पणी:

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

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

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

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

क्रिस्टल

abstract class Coffee
  abstract def cost
  abstract def ingredients
end

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

  def ingredients
    "Coffee"
  end
end

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

  def initialize(@decorated_coffee)
  end

  def cost
    decorated_coffee.cost
  end

  def ingredients
    decorated_coffee.ingredients
  end
end

class WithMilk < CoffeeDecorator
  def cost
    super + 0.5
  end

  def ingredients
    super + ", Milk"
  end
end

class WithSprinkles < CoffeeDecorator
  def cost
    super + 0.2
  end

  def ingredients
    super + ", Sprinkles"
  end
end

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

  def initialize
    coffee = SimpleCoffee.new
    print(coffee)

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

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

Program.new

आउटपुट:

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

सी#

namespace WikiDesignPatterns;

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

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

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

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

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


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

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

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


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

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

    }

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

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

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

    }

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

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

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

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

    }
}

आउटपुट:

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

रूबी

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

class SimpleCoffee < AbstractCoffee
  def cost
    1.0
  end

  def ingredients
    "Coffee"
  end
end

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

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

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

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

coffee = SimpleCoffee.new
coffee.print

coffee = WithMilk.new(coffee)
coffee.print

coffee = WithSprinkles.new(coffee)
coffee.print

आउटपुट:

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

यह भी देखें

संदर्भ

  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=105218’