设计模式之装饰模式

基本概念：
动态的给一个添加一些额外的职责，就增加功能来说，装饰模式比生成子类更加灵活。

先看代码：

/**
 *装饰抽象类
 * 定义一个对象接口，可以给其中的对象动态的添加职责。
 * */
public abstract class Component {

    public HashMap zhuangshi=new HashMap();
    /**
     * 该接口用于子类重写该方法，实现动态添加职责的目的
     */
    public abstract HashMap operation();
}

/**
 * 该类定义了一个具体的对象，所有装饰类都可以给它添加装饰
 * 它无需知道装饰类的存在
 * 它本身就可以给对象添加一些装饰
 */
public class ConcreteComponent extends Component {

    @Override
    public HashMap operation() {
        Log.e("test","具体的对象操作");
        zhuangshi.put("hat","棒球帽");
        return zhuangshi;
    }
}

/**
 * 装饰抽象类，继承了component,从外类来扩展Component类的功能，
 * 但对于component来说，是无需知道Decorator的存在的
 * 至于ConcreteDecorator就是具体的装饰对象，起到给Component添加职责的功能
 */
public abstract class Decorator extends Component {

    protected Component component;

    /**设置component
     * @param component
     */
    public void setComponent(Component component) {
        this.component = component;
    }

    /**
     * 重写component,实际执行的是component的operation()方法
     */
    @Override
    public HashMap operation() {
        if (component != null) {
            return component.operation();
        }
        return null;
    }

/**
 * 具体的装饰类
 */
public class ConcreteDecoratorA extends Decorator {

    private String addedState;

    @Override
    public HashMap operation() {
        /**首先运行原来Component中的方法在执行本类中的方法，相当于对原来的方法进行了装饰*/
        super.operation();
        addedState = "羽绒服";
        Log.e("test", "具体的装饰对象a的操作");
        zhuangshi.put("yifu",addedState);
        return zhuangshi;
    }
}

/**
 * 具体的装饰类B
 */
public class ConcreteDecoratorB extends Decorator {


    @Override
    public HashMap operation() {
        /**首先运行原来Component中的方法在执行本类中的方法，相当于对原来的方法进行了装饰*/
        super.operation();
        Log.e("test", "具体的装饰对象b的操作");
        addedBehavior();
        return zhuangshi;
    }

    /**
     * 本类中独有的方法，区别于a类
     */
    private void addedBehavior(){
        zhuangshi.put("kuzi","牛仔裤");
    }
}

/**
 * 测试
 */
public class ConcreteTest {

    private HashMap zhuangshi;
    public void getTest(){
        ConcreteComponent cc=new ConcreteComponent();//第一个功能，添加帽子；它是具体对象
        ConcreteDecoratorA cd1=new ConcreteDecoratorA();//第二个类，添加衣服，它是装饰
        ConcreteDecoratorB cd2=new ConcreteDecoratorB();//第三个类，添加裤子，它是装饰

        cd1.setComponent(cc);
        cd2.setComponent(cd1);
        zhuangshi=cd2.operation();//通过装饰模式，依次的实现各自类中的功能，得到一个完整的装饰过程和结果
    }
}

装饰模式是利用不断的往对象里setComponent来进行对象的包装的。

这样做的好处就是如何装饰对象和使用这个对象给分离开了。

每个装饰类都只关心自己如何装饰具体对象。不需要关心如何被添加到装饰链中。

总结：
装饰模式的目的就是为了给已有对象动态的添加更多的功能。一个类只需要有自己的核心职责，其他的全部可以用装饰模式动态的添加上去。

使用场景：
当系统需要更新功能的时候，旧的类中添加新的代码，新代码就需要给原有数据添加新字段，新逻辑。通过装饰模式添加新功能保证原有字段和逻辑的情况下添加了新字段和心逻辑。