23种设计模式06---装饰者模式

装饰者模式 一、装饰者模式意图

动态地给一个对象添加一些额外的职责，就增加功能来说， Decorator模式相比生成子类更为灵活。该模式以对客 户端透明的方式扩展对象的功能。

二、、适用环境

（1）在不影响其他对象的情况下，以动态、透明的方式给单个对象添加职责。

（2）处理那些可以撤消的职责。

（3）当不能采用生成子类的方法进行扩充时。一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的 子类，使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。

三、参与者

1.Component（被装饰对象的基类）   定义一个对象接口，可以给这些对象动态地添加职责。 2.ConcreteComponent（具体被装饰对象）   定义一个对象，可以给这个对象添加一些职责。 3.Decorator（装饰者抽象类）    持有一个指向Component实例的引用，并定义一个与Component接口一致的接口。 4.ConcreteDecorator（具体装饰者）   具体的装饰对象，给内部持有的具体被装饰对象，增加具体的职责。 ###四、类图

五、涉及角色

（1）抽象组件:定义一个抽象接口，来规范准备附加功能的类 （2）具体组件：将要被附加功能的类，实现抽象构件角色接口 （3）抽象装饰者：持有对具体构件角色的引用并定义与抽象构件角色一致的接口 （4）具体装饰：实现抽象装饰者角色，负责对具体构件添加额外功能。

装饰者模式中，最重要一点是：抽象装饰者(Decorator) 持有具体构件的引用， 依次对具体构件进行装饰， 同时它还具有和抽象构件（Component）具有一致的接口，在本例中，抽象装饰者实现抽象构件接口public abstract class Decorator implements Component,这样就可以多次对具体构件进行多次装饰。 六、代码实现 6.1、抽象构件Component

定义一个具体构件的功能eat() , 装饰者在此功能下，进行进一步的装饰。

/**
 * 抽象组件： 定义一个抽象接口，来规范准备附加功能的类
 *     被修饰对象的基类，定义一个对象的接口，可以给这些对象动态的添加职责
 */
public interface Component {
    void eat();
}

6.2、具体构件ConcreateComponent

这个是具体的被修饰对象，只是一个简单功能

/**
 *具体组件：将要被附加功能的类，实现抽象构建角色的接口
 *  具体被装饰对象，真正要被装饰的对象
 */
public class ConcreateComponent implements Component{
    @Override
    public void eat() {
        System.out.println("老子在吃饭...");
    }
}

6.3、抽象装饰者

抽象装饰者是一个抽象类， 为了具有与抽象构件一致的结构，实现了抽象构件结构，这样它的子类也可以作为一个具体构件进行被装饰，同时抽象装饰者具体组件的引用，此处使用父类引用（抽象构件引用）指向子类对象（传入的子类对象），重新实现了抽象构件的方法eat(), 抽象装饰者的子类修改eat（）,已达到装饰具体构件的功能，添加附件功能。

package com.chb.f.DecoratorDesignPattern.b;
/**
 * 装饰者抽象类：
 *   抽象装饰者：持有具体构件角色的引用，并定义一个与抽象构件一致的接口
 *    持有一个抽象组件Component的引用，并定义一个与Component一样的接口
 *  
 */
public abstract class Decorator implements Component{
    private Component component;
    public void setComponent(Component component) {
        this.component = component;
    }   

    @Override
    public void eat() {
        component.eat();
    }

}

6.4、具体装饰者ConcreateComponent

具体装饰者，重写eat()方法， super.eat(), 被修饰的对象的功能不进行修改， 只是添加附加功能

        System.out.println("==========");
        System.out.println("具体装饰角色B");

提供了两个装饰者

/**
 * 具体装饰角色： 实现抽象装饰角色，负责对 具体构件添加额外功能
 *      具体的装饰对象，给内部持有的具体被装饰对象，增加具体的职责
 */
public class ConcreteDectratorA extends Decorator{
    @Override
    public void eat() {
        super.eat();// ==＞　com.eat() 
        System.out.println("==========");
        System.out.println("具体装饰角色B");
    }
}


/**
 * 具体装饰角色： 实现抽象装饰角色，负责对 具体构件添加额外功能
 *      具体的装饰对象，给内部持有的具体被装饰对象，增加具体的职责
 */
public class ConcreteDectratorB extends Decorator{
    @Override
    public void eat() {
        super.eat();  //====>   setCom(com)  com=da 
        reEat();
        System.out.println("具体装饰角色A");
    }
    public void reEat() {
        System.out.println("老子还要吃。。。。");
    }
}

客户端调用

package com.chb.f.DecoratorDesignPattern.b;

public class Test {
    public static void main(String[] args) {
        Component component = new ConcreateComponent();//老子在吃饭...

        Decorator da = new ConcreteDectratorA();
        Decorator db = new ConcreteDectratorB();
        //具体构件的原有功能
        component.eat();
        System.out.println();
        //第一次装饰
        da.setComponent(component);   
        da.eat();
        System.out.println();
        //第二次装饰
        db.setComponent(da);
        db.eat();

    }
}

同样是调用eat()方法，但是通过装饰者多次装饰，原有功能更多，

老子在吃饭...

老子在吃饭...
==========
具体装饰角色B

老子在吃饭...
==========
具体装饰角色B
老子还要吃。。。。
具体装饰角色A