设计模式之（十）装饰模式（DECORATOR）

　　在购买了一个房子后，如果是毛坯房，肯定不合适直接入住的。需要对它进行装修：地面找平贴地砖、批墙贴墙纸、吊顶装订以及买需要的家具，住进去以后也可能根据需要再添加或者去掉一些家具或者修改一些东西。所以的这一切，都是为了住起来舒服，也就是更好试用这个房子。这个装修过程，基本上就是装饰模式需要做的事情。

　　引申到软件方面，一个原有的功能，可能需要添加一些辅助功能才能更好的应用。为了更好的、更加灵活的处理这样的需要，根据日常针对此类功能很好的设计写法进行了抽象。看起来就是对原来的功能进行了一些包装一样。搞明白装饰模式要解决的问题场景后。我们先来看下这个模式的定义：

动态的给动向添加一些额外的职责，就添加功能来说，装饰模式比生成子类更加灵活。

类图和组成元素

　                                              　

（抽象组件类）Component：定义一个对象接口，可以给这个对象动态的添加职责；

（具体组件类）ConreteComonent：定义一个对象，可以给这个对象添加职责。被装饰的原始类

（抽象装饰着）Derocater：定义一个接口，并且继承 Component，而且拥有一个 Component 类型的属性。

（具体装饰着）ConcreteDerocater：是具体的装饰着，也可以作为被装饰者来装饰。

示例

为了更好的展示装饰模式的。这里举个例子加深理解。给一个警察添加装备来举例。一般都配置警棍，但是根据每次执行任务的不同，来配置相应的装备，看例子

//警察  相当于 Component
public interface Jingcha {
    public  void addZhuangb();
}

//特警 相当于 ConcreteComponent
public class TeJing implements Jingcha {

    @Override
    public void addZhuangb() {
        // TODO Auto-generated method stub
        System.out.println("警棍");
    }
}

//特警 相当于 ConcreteComponent 被装饰的原始类
public class TeJing implements Jingcha {

    @Override
    public void addZhuangb() {
        // TODO Auto-generated method stub
        System.out.println("警棍");
    }
}

//装饰警察 相当于 Decorate，抽象的装饰器类
public abstract class DecorateJingcha implements Jingcha {

    Jingcha jc = null;
    public DecorateJingcha(Jingcha jc){
        this.jc = jc;
    }

    @Override
    public abstract void addZhuangb();
}

//装饰类之一
public class DecorateJingchaFDY extends DecorateJingcha {

    public DecorateJingchaFDY(Jingcha jc) {
        super(jc);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void addZhuangb() {
        // TODO Auto-generated method stub
        jc.addZhuangb();
        System.out.println("防弹衣");
    }

}

//装饰类之一
public class DecorateJingchaSQ extends DecorateJingcha {

    public DecorateJingchaSQ(Jingcha jc) {
        super(jc);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void addZhuangb() {
        // TODO Auto-generated method stub
        jc.addZhuangb();
        System.out.println("手枪");
    }

}

//装饰类之一
public class DecorateJingchaYSY extends DecorateJingcha {

    public DecorateJingchaYSY(Jingcha jc) {
        super(jc);
        // TODO Auto-generated constructor stub
    }

    @Override
    public void addZhuangb() {
        // TODO Auto-generated method stub
        jc.addZhuangb();
        System.out.println("夜视仪");
    }
}

 public class Client {
     public static void main(String[] args) {
         Jingcha jc = new TeJing();
         //维护抗议游行秩序，只用警棍就可以
         System.out.println("------维护抗议游行秩序，只用警棍就可以-------");
         jc.addZhuangb();
         //晚上维护抗议游行秩序
         System.out.println("------晚上维护抗议游行秩序，需另外加上夜视仪-------");
         DecorateJingcha yesy = new DecorateJingchaYSY(jc);
         yesy.addZhuangb();
         //处理恐怖袭击事件
         System.out.println("------处理晚上恐怖袭击事件，要枪、防弹衣-------");
         DecorateJingcha dch1 = new DecorateJingchaSQ(jc);
         DecorateJingcha dch2 = new DecorateJingchaFDY(dch1);
         dch2.addZhuangb();
     }
 }

 -----------------------------执行效果------------------------------------
 ------维护抗议游行秩序，只用警棍就可以-------
 警棍
 ------晚上维护抗议游行秩序，需另外加上夜视仪-------
 警棍
 夜视仪
 ------处理晚上恐怖袭击事件，要枪、防弹衣-------
 警棍
 手枪
 防弹衣

　通过例子看出来，装饰器模式可以很灵活的实现需要的功能。而且符合开闭原则。

分析此模式

　　 首先分析一下实现方面需要注意什么呢：

　　　  一、装饰器类和被装饰器都是实现共同的接口，这样有个好处是装饰类也能作为被装饰类来进一步装饰。

二、装饰器类和被装饰类除了要实现共同的接口外，装饰器类还应该有共同的接口。这里主要是引入被装饰的类所谓属性

三、根据定义可以看出来，此模式比继承灵活。这主要体现在试用的是类的组合方式来调用。和继承比起来不用全部继承过来。

四，装饰器一次尽量少实现功能。这样在调用的时候组合起来更加灵活。

这个模式的有点是什么呢.? 比继承更加灵活；更加容易复用功能；简单继承关系，简化搞定类的定义。原始类虽然被装饰了，但是它本身并没有被该表，只是在类的外部进行修改。也有点类似给原始类加上了一些外壳。

　　每个模式的出现都有一定的目的，这个模式的目的是什么？就是根据业务灵活组合对象，复用已有类实现功能需要。也可以理解为把有些复杂的功能简单化，分散化，运行时根据需要来组合使用。

代理模式和这个模式在实现上非常的相似，这个在写代理模式的时候再详细分析下。装饰模式就写到这里了