装饰模式

定义：动态的给一个对象添加一些额外的职责。就增加功能来讲，装饰模式比生成子类更为灵活。类图如下：

*Component抽象构件：一个接口或抽象类，定义我们最核心的对象。

1 //抽象构件
2 public abstract class Component{
3     //抽象方法
4     public abstract void operate();
5 }

*ConcreteComponent具体构件：核心构建的实现，要装饰的就是它。

1 //具体构件
2 public class ConcreteComponent extends Component{
3     //具体实现
4     @Override
5     public void operate() {
6         //功能代码
7         System.out.println("执行自己的方法");
8     }
9 }

*Decorator装饰角色：一般是个抽象类，定义一个与组件接口一致的接口，并持有一个Component对象（被装饰的对象）。

 1 //抽象装饰者
 2 public abstract class Decorator extends Component{
 3     private Component component = null;
 4     //注入被装饰者
 5     public Decorator(Component component){
 6         this.component = component;
 7     }
 8     //委托给被装饰者执行
 9     @Override
10     public void operate() {
11         this.component.operate();
12     }
13 }

*ConcreteDecorator：实际的装饰器对象，实现具体要被装饰对象添加的功能。下面给出两个实现类A和B：

 1 //具体装饰类A
 2 public class concreteDecoratorA extends Decorator{
 3     //定义被装饰者
 4     public concreteDecoratorA(Component component) {
 5         super(component);
 6     }
 7     private void method1(){
 8         //装饰方法1
 9         System.out.println("使用了method1方法装饰");
10     }
11     //重写opration()方法
12     @Override
13     public void operate() {
14         this.method1();
15         super.operate();
16     }
17 }

 1 //具体装饰类B
 2 public class concreteDecoratorB extends Decorator{
 3     //定义被装饰者
 4     public concreteDecoratorB(Component component) {
 5         super(component);
 6     }
 7     private void method2(){
 8         //装饰方法2
 9         System.out.println("使用了method2方法装饰");
10     }
11     //重写opration()方法
12     @Override
13     public void operate() {
14         this.method2();
15         super.operate();
16     }
17 }

客户端示例代码：

 1 public class Client{
 2     public static void main(String[] args) {
 3         Component component = new ConcreteComponent();
 4         //用concreteDecoratorA装饰
 5         component = new concreteDecoratorA(component);
 6         //再用concreteDecoratorB装饰
 7         component = new concreteDecoratorB(component);
 8         component.operate();
 9     }
10 }

总结：
　　1.装饰模式是继承关系的一个替代，好处在于它使用了对象组合而非继承从而降低耦合。
　　2.装饰模式能实现动态地为对象添加功能（由运行期来进行），其本质就是动态组合。

转载于:https://www.cnblogs.com/ergou/p/6994921.html