From
http://www.exciton.cs.rice.edu/JavaResources/DesignPatterns/DecoratorPattern.htm:

<quote>
The Decorator Pattern is used for adding additional functionality to a
particular object as opposed to a class of objects. It is easy to add
functionality to an entire class of objects by subclassing an object, but it
is impossible to extend a single object this way. With the Decorator
Pattern, you can add functionality to a single object and leave others like
it unmodified.
</quote>

   - Oliver

If you have a lot of different types of decoration you want to perform
it it much better to use the decoration pattern. Example a JTable with
three different types of decorations..

    public StockMarketOrderDisplay()
    {
        initialise();
    }

    private void initialise()
    {
        contentPane = (JPanel)this.getContentPane();
        this.setTitle("Stock Market Order Display");

        // Setup Renderers;
        registerRendererForClass(String.class);
        registerRendererForClass(Number.class);
        registerRendererForClass(Double.class);

        // put in scrollpane
        JScrollPane scrollPane = new JScrollPane();
        scrollPane.getViewport().add(table, null);
        // Add scrollpane to content pane
        contentPane.add(scrollPane);
    }

    private void registerRendererForClass(Class klass)
    {
        // Get Default Renderer from the table
        DefaultTableCellRenderer defaultRenderer =
(DefaultTableCellRenderer)table
                .getDefaultRenderer(klass);

        // Wrap the color renderer around the default renderer
        TableCellRenderer colorRenderer = new CellColorRenderer(
                defaultRenderer, provider);

        // Wrap the flash renderer around the colour renderer
        TableCellRenderer flashRenderer = new CellFlashColorRenderer(
                colorRenderer, flashProvider);

        // Register our flash renderer with the table
        table.setDefaultRenderer(klass, flashRenderer);
    }

Hi Roger:

The intent of the Decorator design pattern is to provide a flexible
alternative to subclassing for extending functionality.

To expand on what IchBin mentioned, you want to avoid *excessive*
subclassing to the point where it is difficult to predict *all*
possible common object behaviors in an abstract base class or
interface.  Excessive subclassing also creates a very messy UML diagram
and makes the application that much harder to maintain.

IchBin's example demonstrated how to use an exisiting Decorator, but if
you would like to develop your own, I highly recommend the Head First
Design Patterns book by Eric & Elisabeth Freeman.  The sample chapter
from O'Reilly's web site happens to be on the Decorator design pattern.
The URL is
http://www.oreilly.com/catalog/hfdesignpat/chapter/ch03.pdf.

Hope this helps along with everyone else's feedback...

Sincerely,

Mike.

--- ACGNJ Java Users Group (http://www.javasig.org/)