Decorator pattern |
In object-oriented programming, a decorator pattern is a design pattern (computer science).
= Introduction =
The decorator pattern allows new/additional behaviour to be added to an existing method of an object dynamically. This is done by wrapping the new decorator object around the original object, which is typically achieved by passing the original object as a parameter to the constructor of the decorator, with the decorator implementing the new functionality. The interface of the original object needs to be maintained by the decorator.
Decorators are alternatives to subclassing. Subclassing adds behaviour at compile time whereas decorators provide a new behaviour at runtime.
This difference becomes most important when there are several independent ways of extending functionality. Since (in most object-oriented programming languages) classes (computer science) cannot be created at Runtime and it is typically not possible to predict what combinations of extensions will be needed at design time, a new class would have to be made for every possible combination. By contrast, decorators are objects, created at runtime, and can be combined on a per-use basis. A superb example of the decorator pattern is the Java I/O Streams implementation.
== Motivation == As an example, consider a window in a windowing system. To allow scrolling of the window s contents, we may wish to add horizontal or vertical scrollbars to it, as appropriate. Assume windows are represented by instances of the Window class, and assume this class has no functionality for adding scrollbars. We could create a subclass ScrollingWindow that provides them, or we could create a ScrollingWindowDecorator that merely adds this functionality to existing Window objects. At this point, either solution would be fine. (Another solution is to simply modify the existing Window class, but this is not always possible—we might not have access to its implementation, or we might be adding computer storage overhead for new functionality that the majority of objects will not use.)
Now let s assume we also wish the option to add borders to our windows. Again, our original Window class has no support. The ScrollingWindow subclass now poses a problem, because it has effectively created a new kind of window. If we wish to add border support to all windows, we must create subclasses WindowWithBorder and ScrollingWindowWithBorder . Obviously, this problem gets worse with every new feature to be added. For the decorator solution, we need merely create a new BorderedWindowDecorator —at runtime, we can decorate existing windows with the ScrollingWindowDecorator or the BorderedWindowDecorator or both, as we see fit.
= Applicability =
Consider the webpage you are currently viewing. The webpage itself displays the information you need, but your web browser knows nothing about the content. It is likely that this webpage doesn t fit in the entire browser area and a scrollbar is required to show the information. The web browser doesn t need to assume that all webpages will require a scrollbar and it certainly should never assume a scrollbar is never needed. Mozilla and Netscape (web browser) browsers will display the scrollbar only if it is necessary and hides it if it is unnecessary. In this case, the scrollbar is the decoration to the webpage. It takes care of whether or not it should be displayed dynamically as opposed to statically forcing the webpage display to be a subclass of the scrollbar display. Thus, it is up to the scrollbar to decide whether or not it should display itself (instead of trying to force that responsibility on the webpage or on the external parts of the web browser).
=Example=
This Java programming language example uses the Window/ScrollingWindow scenario class Window { public void draw() { // Draw window } public void setSize(int height, int width) { // Set window size } // Other Window methods } class ScrollingWindow { private Window win; // Provides Window functionality public ScrollingWindow(Window w) { win = w; } // Conforming to the interface of Window : public void draw() { win.draw(); // Passing the request to win } public void setSize(int height, int width) { win.setSize(height, width); } // Other Window methods (must have same interface as Window) // Added functionality: public void drawHorizontalScrollbar() { // Draw Horizontal Bar } public void drawVerticalScrollbar() { // Draw Vertical Bar } }
The decorator (ScrollingWindow) is given the same interface as the component it decorates. Typically, the decorator s methods will only pass requests to the underlying decorated component, but it can also perform operations before and after the call. Then the decorator defines extra methods (decorations) to extend the decorated component s functionality.
= See also =
= External links =
*[http://home.earthlink.net/~huston2/dp/decorator.html Description] by Vince Huston *Sample [http://www.oreilly.com/catalog/hfdesignpat/chapter/ch03.pdf Chapter 3: The Decorator Pattern] *Sample Chapter [http://awprofessional.com/articles/article.aspp=31350&rl=1 C# Design Patterns: The Decorator Pattern] by James W. Cooper *[http://phppatterns.com/index.php/article/articleview/30/1/1 A PHP approach] and [http://phppatterns.com/index.php/article/articleview/92/1/1 Redecorated] *[http://www.castle-cadenza.demon.co.uk/decorate.htm A Delphi approach] *Article [http://www.javaworld.net/javaworld/jw-04-2004/jw-0412-decorator.html Three approaches for decorating your code] by Michael Feldman *Article [http://www.onjava.com/pub/a/onjava/2003/02/05/decorator.html Using the Decorator Pattern] by Budi Kurniawan *Article [http://exciton.cs.rice.edu/JavaResources/DesignPatterns/DecoratorPattern.htm The Decorator Design Pattern] by Antonio García and Stephen Wong *[http://javalab.iai.uni-bonn.de/research/gilgul/tutorial.html#1 Application] with Gilgul|
|