java - 装饰模式设计

Question

我对模式很陌生，我正在为我必须编写的程序研究装饰器模式。

网上学习，找到一个装饰模式的例子(Java伪代码):

class Solution1
{
    static interface Component 
    { 
        void doStuff(); 
    }

    static class MyComponent implements Component 
    {
        public void doStuff()
        {
            // ...
        }
    }

    static class ComponentDecorator implements Component  // This is the Decorator pattern.
    { 
        private final Component component;

        public ComponentDecorator(Component component) 
        {
            this.component = component;
        }

        public void doStuff()
        {
            this.component.doStuff();
        }
    }

    static class ComponentDecorator1 extends ComponentDecorator 
    {
        public ComponentDecorator1(Component component) 
        {
            super(component);
        }

        private void doExtraStuff1()
        {
            // ...
        }

        public void doStuff()
        {
            super.doStuff();
            doExtraStuff1();
        }
    }

    static class ComponentDecorator2 extends ComponentDecorator 
    {
        public ComponentDecorator2(Component component) 
        {
            super(component);
        }

        private void doExtraStuff2()
        {
            // ...
        }

        public void doStuff()
        {
            super.doStuff();
            doExtraStuff2();
        }
    }

    public static void main(String[] args)
    {
        MyComponent         c   = new MyComponent();
        ComponentDecorator1 cd1 = new ComponentDecorator1(c);
        ComponentDecorator2 cd2 = new ComponentDecorator2(cd1);

        cd2.doStuff(); // Executes Component.doStuff, ComponentDecorator1.doExtraStuff1, ComponentDecorator2.doExtraStuff2
    }
};

当我分析这个例子时，我意识到我在过去做了一个非常相似的模式，但方式不同:

import java.util.*;

class Solution2
{
    static interface Component 
    { 
        void doStuff(); 
    }

    static class MyComponent implements Component 
    {
        public void doStuff()
        {
            // ...
        }
    }

    static class ComponentDecorator implements Component  // This is NOT the Decorator pattern!
    { 
        private final List<Component> components = new ArrayList<Component>();

        public ComponentDecorator() 
        {
        }

        public ComponentDecorator addComponent(Component component)
        {
            this.components.add(component);
            return this;
        }

        public void removeComponent(Component component) // Can Decorator do this?
        {
            // ...
        }

        public void doStuff()
        {
            for(Component c : this.components) c.doStuff();
        }
    }

    static class ComponentDecorator1 implements Component 
    {
        public ComponentDecorator1() 
        {
        }

        private void doExtraStuff1()
        {
            // ...
        }

        public void doStuff()
        {
            doExtraStuff1();
        }
    }

    static class ComponentDecorator2 implements Component 
    {
        public ComponentDecorator2() 
        {
        }

        private void doExtraStuff2()
        {
            // ...
        }

        public void doStuff()
        {
            doExtraStuff2();
        }
    }

    public static void main(String[] args)
    {
        ComponentDecorator cd  = new ComponentDecorator();
        cd.addComponent(new MyComponent());
        cd.addComponent(new ComponentDecorator1());
        cd.addComponent(new ComponentDecorator2());

        cd.doStuff(); // Executes MyComponent.doStuff, ComponentDecorator1.doExtraStuff1, ComponentDecorator2.doExtraStuff2
    }
}

在我看来，第二个示例可以在可以使用装饰器模式的相同情况下使用，但它更灵活(例如，您可以删除或重新排序列表中的组件)，所以我的问题:

• 解决方案 1(正确的装饰器模式)是否比解决方案 2 更好？为什么？
• 是否可以在解决方案 1 中添加用于删除实例的函数？
• 是否可以在解决方案 1 中添加用于重新排序实例的函数？

Answer 1

解决方案 2 实际上是装饰器模式和复合模式的混合。

如果您只想添加行为，我认为解决方案 1 优于解决方案 2；如果您还需要将多个对象作为一个对象使用，则使用解决方案 1 + 复合模式更好。

作为关于使用这两种模式的更一般的答案，请参见 Difference between the Composite Pattern and Decorator Pattern?

这是关键答案:

复合模式允许您以一种允许外部代码将整个结构视为单个实体的方式构建层次结构(例如元素树)。因此，叶实体的接口(interface)与复合实体的实体完全相同。所以本质上是复合结构中的所有元素都具有相同的接口(interface)，即使有些是叶节点而另一些是整个结构。用户界面通常使用这种方法来实现轻松的可组合性。

http://en.wikipedia.org/wiki/Composite_pattern

装饰器模式允许一个实体完全包含另一个实体，因此使用装饰器看起来与包含的实体相同。这允许装饰器修改其封装的任何内容的行为和/或内容，而无需更改实体的外观。例如，您可以使用装饰器在不更改包含元素的任何行为的情况下添加有关包含元素使用情况的日志记录输出。

http://en.wikipedia.org/wiki/Decorator_pattern