设计模式-装饰者模式

模式意图

在不改变现在对象结构的情况下，动态的给对象增加一些职业（额外功能）。

比如炒饭和炒面继承自快餐类，现在要需要给快餐增加配料，有鸡蛋，培根等，最简单的做法是将鸡蛋炒饭，培根炒饭继承炒饭.....，这样会造成类爆炸。

结构

• 抽象构建角色：规范准备接收附加责任的对象
• 具体构建角色：通过装饰角色来添加职责的角色
• 抽象装饰角色：继承或实现抽象构建，并包含其具体实例
• 具体装饰角色：实现抽象装饰的方法，给具体构建对象添加附加的责任

 快餐店案例

快餐类 FastFood

成员变量有价格和说明，这两个参数都需要在子类中写，写在父类中可以减少冗余。

抽象方法cost是计算价格，子类需重写。

炒饭类 FriedRice  和  炒面类 FriedNoodles

实现父类的计算价格的方法

抽象装饰者类  和  具体装饰者类

1.抽象装饰者继承快餐类，那么装饰者也是快餐类。

2.具体装饰者继承抽象装饰者，那么具体装饰者也是快餐类。

3.抽象装饰者聚合快餐类，那么相当于具体装饰者也聚合了快餐类，那么具体装饰者的本质就是本身是快餐类，同时自身还包含着一个快餐类，也就相当于炒饭类中含有了一个鸡蛋。

4.由于继承关系的存在，具体快餐类和具体装饰类都包含价格和说明两个属性，而具体装饰者额外包含一个快餐属性。

package mode;

public class Client {
    public static void main(String[] args) {
        //点炒饭
        FastFood friedRice = new FriedRice();
        System.out.println(friedRice.getDesc()+"  "+friedRice.cost()+"元");//炒饭  10.0元
        //炒饭加鸡蛋
        friedRice = new Egg(friedRice);
        System.out.println(friedRice.getDesc()+"  "+friedRice.cost()+"元");//鸡蛋炒饭  11.0元
        //再加一个鸡蛋
        friedRice = new Egg(friedRice);
        System.out.println(friedRice.getDesc()+"  "+friedRice.cost()+"元");//鸡蛋鸡蛋炒饭  12.0元
        //加培根
        friedRice = new Bacon(friedRice);
        System.out.println(friedRice.getDesc()+"  "+friedRice.cost()+"元");//培根鸡蛋鸡蛋炒饭  14.0元
    }
}

//抽象构建角色
abstract class FastFood{
    private float price;
    private String desc;

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    public FastFood() {

    }

    public FastFood(float price, String desc) {
        this.price = price;
        this.desc = desc;
    }

    public abstract float cost();

}
//具体构建角色
class FriedRice extends FastFood{
    public FriedRice() {
        super(10,"炒饭");
    }

    @Override
    public float cost() {
        return getPrice();
    }
}
//具体构建角色
class FriedNoodles extends FastFood{

    public FriedNoodles() {
        super(12,"炒面");
    }

    @Override
    public float cost() {
        return getPrice();
    }
}

//装饰类
abstract class Garnish extends FastFood{
    private FastFood fastFood;

    public FastFood getFastFood() {
        return fastFood;
    }

    public void setFastFood(FastFood fastFood) {
        this.fastFood = fastFood;
    }

    public Garnish(float price, String desc, FastFood fastFood) {
        super(price, desc);
        this.fastFood = fastFood;
    }
}
//具体装饰者角色
class Egg extends Garnish{
    public Egg(FastFood fastFood){
        super(1,"鸡蛋",fastFood);
    }

    @Override
    public float cost() {
        return getPrice()+getFastFood().cost();
    }

    @Override
    public String getDesc() {
        return super.getDesc() + getFastFood().getDesc();
    }
}

class Bacon extends Garnish{
    public Bacon(FastFood fastFood){
        super(2,"培根",fastFood);
    }

    @Override
    public float cost() {
        return getPrice()+getFastFood().cost();
    }

    @Override
    public String getDesc() {
        return super.getDesc() + getFastFood().getDesc();
    }
}

创建两个Egg对象为什么输出两次鸡蛋？

创建第一个Egg对象，Egg对象的成员变量
Egg{
    desc:鸡蛋
    fastFood(firedNoodles):炒面
 }

创建第二个Egg对象，Egg对象的成员变量，第一个Egg被传入了第二个Egg

 Egg{
    desc:鸡蛋
    fastFood(Egg){
        desc:鸡蛋
        fastFood(firedNoodles):炒面
    }
 }

调用Egg对象的getDesc方法,返回的是该对象的desc和聚合对象的desc，如果聚合对象仍包含聚合对象，那么还会返回其聚合对象的desc，直到最后一个聚合对象为炒面或炒饭（因为这俩对象的getDesc方法是只返回自身的desc）

优点

• 装饰者模式比继承具有更加灵活的拓展功能，使用更方便
• 继承是静态的附加责任，装饰者是动态的附加责任，因为传入哪个对象是具体操作时定的
• 装饰类和具体构建类可以独立发展，不相互耦合，如果再加一个火腿肠配料，直接让火腿肠类继承装饰者类就可以，如果是原先的继承模式，就需要在每种快餐类中都创建子类。 

使用场景

JDK源码解析

public class Client {
    public static void main(String[] args) throws Exception{
        FileWriter fw = new FileWriter("");
        BufferedWriter bw = new BufferedWriter(fw);
        bw.write("hello");
        bw.close();
    }
}

BufferedWriter继承了Writer又聚合了Writer

显然BufferedWriter对FileWriter进行了增强，也就相当于往炒饭里（FileWriter）加了鸡蛋，那BufferedWriter就是炒饭加鸡蛋的组合体。

 BufferedWriter使用装饰者模式对Writer子实现类进行了增加，添加了缓冲区，提高了写数据的效率。

静态代理和装饰者模式的区别

 装饰者模式需要传入目标对象，目标对象对于调用者来说没有隐藏，静态代理直接在内部new了对象，目标对象对于调用者来说隐藏了。