设计模式—装饰模式

定义

动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更为灵活

代码

定义抽象构件

1
2
3
public abstract class Component {
    public abstract void operate();
}

定义具体构件

1
2
3
4
5
6
public class ConcreteComponent extends Component {
    @Override
    public void operate() {
        System.out.println("concreteComponent do something");
    }
}

定义抽象装饰类

1
2
3
4
5
6
7
8
9
10
11
12
public abstract class Decorator extends Component{
    private Component component;

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

    @Override
    public void operate() {
        this.component.operate();
    }
}

具体装饰类1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Decorator1 extends Decorator {

    public Decorator1(Component component) {
        super(component);
    }

    private void doSomething(){
        System.out.println("decorator1  do something");
    }

    @Override
    public void operate() {
        this.doSomething();
        super.operate();
    }
}

具体装饰类2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Decorator2 extends Decorator {
    public Decorator2(Component component) {
        super(component);
    }
    private void doSomething(){
        System.out.println("decorator2 do something");
    }

    @Override
    public void operate() {
        this.doSomething();
        super.operate();
    }
}

测试

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class DecoratorTest {

    @Test
    public void testDecorator(){
        Component component = new ConcreteComponent();
        component.operate();
        System.out.println("-----");
        component = new Decorator1(component);
        component.operate();
        System.out.println("-----");
        //component->Decorator1
        component = new Decorator2(component);
        component.operate();
    }

}

从结果可以看出 最终在基础构件的operate方法执行之前执行了两个装饰方法

使用场景
  • 需要扩展一个类的功能，或者给一个类增加附加功能
  • 需要动态地给一个对象增加功能，这些功能可以再动态撤销
  • 需要为一批兄弟类进行改装或加装功能