设计模式-装饰者模式

本文已参与「新人创作礼」活动，一起开启掘金创作之路。

模式意图

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

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

结构

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

快餐店案例

快餐类 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了对象，目标对象对于调用者来说隐藏了。