写给新人的设计模式——装饰者

装饰者模式允许为一个组件(component)添加不同的装饰者（decorator），从而在不改变代码的情况下更改组件的功能。这是一种继承的替换方案，我们可以使用装饰者模式对某个组件进行不断的扩充，从而拓展他的功能。

遵循的设计原则

1. 面相接口编程：
   装饰者模式中的抽象组件和抽象装饰者，都是将我们需要加强的方法拿出来，放在接口之中，这样我们在使用的时候会更加灵活且耦合度更低
2. 封装变化：
   装饰者模式将我们需要加强的方法放入接口之中，这样我们在使用的时候不会影响到被封装的部分
   3.开闭原则：
   对扩展开放，对修改关闭。在装饰者模式中，因为所有的封装者都继承自component，每当有新的装饰者出现，他会将之前的decorator+component当成为一个component 来看待，这时候除了接口中暴露出来的方法外，其他的部分已经被封装了起来。

如何实现

装饰者模式一共由四部分组成
1.抽象组件component，这是一个超类（抽象类或者接口），我们需要不断对这个接口中的方法进行强化和拓展。
2.具体组件concreteComponent, 这是超类的具体实现，也被成为被装饰者(decorated object), 即我们要装饰的类。
3.抽象装饰者decorator, 这是所有装饰者的抽象（超类），里面声明了我们需要加强和拓展的方法。他是compoent的子类型（继承/实现了compoent抽象类/接口)
4.具体装饰者concreteDecorator, 这是装饰者的实例，装饰者们持有具体组件的引用，并且对于需要加强的的内容有自己的实现。

装饰者模式，是的，还是网图。。

一句提醒

装饰者模式加强的并不是具体组件 ConcreteComponent, 而是compoent接口中暴露出的方法。

实战演示

/**
 * Created by LeafEater on 2017/2/18.
 * 需求：要求为一家煎饼店做一个点餐系统
 * 煎饼类型： 杂粮煎饼 6元  白面煎饼 5元
 * 加料： 辣条 1元 鸡蛋 1元 火腿 2元
 */
public class OrderSystem {
    public static void main(String[] args) {
        Pancakes pancakes = new MixedPancakes();
        pancakes = new Ham(pancakes);
        pancakes = new Egg(pancakes);
        Pancakes pancakes1 = new Latiao(new Egg(new FlourPancakes()));
        System.out.println("订单:" + pancakes.getDescription());
        System.out.println("价格：" + pancakes.cost());
        System.out.println("订单:" + pancakes1.getDescription());
        System.out.println("价格：" + pancakes1.cost());
    }
}

interface Pancakes {
    public abstract String getDescription();

    public abstract int cost();
}

abstract class Seasoning implements Pancakes {
    @Override
    public abstract String getDescription();
}

class Ham extends Seasoning {

    Pancakes pancakes;

    public Ham(Pancakes pancakes) {
        this.pancakes = pancakes;
    }

    @Override
    public int cost() {
        return pancakes.cost() + 2;
    }

    @Override
    public String getDescription() {
        return pancakes.getDescription() + "+火腿";
    }

    public void hamState() {
        System.out.println("火腿切碎");
    }

}

class Egg extends Seasoning {

    Pancakes pancakes;

    public Egg(Pancakes pancakes) {
        this.pancakes = pancakes;
    }

    @Override
    public int cost() {
        return pancakes.cost() + 1;
    }

    @Override
    public String getDescription() {
        return pancakes.getDescription() + "+鸡蛋";
    }

    public void eggState() {
        System.out.println("鸡蛋打碎");
    }
}

class Latiao extends Seasoning {

    Pancakes pancakes;

    public Latiao(Pancakes pancakes) {
        this.pancakes = pancakes;
    }

    @Override
    public int cost() {
        return pancakes.cost() + 1;
    }

    @Override
    public String getDescription() {
        return pancakes.getDescription() + "+辣条";
    }
}

class MixedPancakes implements Pancakes {

    @Override
    public String getDescription() {
        return "五谷杂粮煎饼";
    }

    @Override
    public int cost() {
        return 6;
    }
}

class FlourPancakes implements Pancakes {

    @Override
    public String getDescription() {
        return "白面煎饼";
    }

    @Override
    public int cost() {
        return 5;
    }
}

再总结一下

装饰者模式在说这样一个场景：随着业务的推进，旧系统中的功能已经不够用了，我们需要在利用旧系统的基础上增加新的功能。
之后再看看我们设计的思路是什么：

1. 我们需要使用旧系统，那么一定会获得旧系统的引用，所以说在新系统Decorator中，我们引入了旧系统ConcreteComponent的引用
2. 我们还需要对旧系统做一定程度的改造或者增强，首先分析出旧系统中向外提供的服务，这个服务就是operation();将这种服务抽象成接口之后，再在新系统中实现它，就可以对这个服务进行一些自定义。这时候再看看第一步，我们也拥有旧系统中operation的实现方式，所以就可以在Operation的基础上进行一定的增强。