群里面有一个小伙伴提出问题，装饰模式和继承和派生到底区别在哪里。事实上，除了代码量的缩减以外，装饰模式更大的意义是设计方法的一种改进：
用数学模型可以这样抽象地说——在面向对象的编程中，继承和派生是一种全集和子集的关系；而后引入了接口Interface的概念，将类于类之间交集的关系抽象成了接口。装饰模式是将这两种思想相结合，利用装饰者，对原来的对象进行修饰并赋予新的特性。赋予特性的顺序，数量，均不受类的约束，而是在运行时增删改。
装饰的本质，是在具有相同特性的对象上增加修饰，他不是对类的操作，而是对对象的修饰。装饰者在接收到被装饰者时，不需要管被装饰者是谁，只需要给被装饰者加一层自己对他的修饰就行。
驴肉火烧案例模型
我特别爱吃驴肉火烧，尤其是保定口的驴肉火烧，肥瘦焖子青椒肥肠，无肉不欢的我总是喜欢吃这么几种驴肉火烧的组合方式：
- 肥瘦火烧
- 肥瘦火烧+焖子
- 肥瘦火烧+青椒
- 肥瘦火烧+焖子+青椒
- 肥瘦火烧+青椒+焖子（别问为啥，先后顺序口感不同，强迫症！节目效果必须这样做）
- 肥瘦火烧+焖子+青椒+肥肠（土豪配置）
- ……
如果咱用继承与派生的方式来抽象模型的话，会形成这样的结构：
- 肥瘦火烧（父类）
- 焖子火烧 extends 肥瘦火烧（肥瘦火烧+焖子的子类）
- 青椒火烧 extends 肥瘦火烧（肥瘦火烧+青椒的子类）
- 焖子青椒火烧 extends 焖子火烧（焖子火烧+青椒的子类）
- 青椒焖子火烧 extends 青椒火烧（青椒火烧+焖子的子类）
- 焖子青椒肥肠火烧 extends 焖子青椒火烧（焖子青椒火烧+肥肠的子类）
- ……
也就是说，这些原材料有多少种的排列组合方式，我们就要派生出多少种类。OMG，这个代码量虽然比过程化结构设计省了好多，那还是有大量的劳动要做啊！
如果你是焖子店老板，必须提前准备6+种火烧给我这挑剔的顾客选，累屎啦！
换一种思路，如果先前就备货肥瘦火烧，然后将焖子，青椒，肥肠现切进肥瘦火烧中，那么老板的工作量是不是就少了好多呢？
这就是装饰模式的优势：
我们的备菜是4个类——肥瘦火烧、焖子、青椒、肥肠
- 肥瘦火烧
- 焖子修饰一下肥瘦火烧
- 青椒修饰一下肥瘦火烧
- 焖子修饰一下然后青椒修饰一下肥瘦火烧
- ……
可以派生出24种不同的火烧排列组合方式，然而代码量只有4个类的代码量！LOL，老板乐开了花。
装饰模式
回到概念上来，装饰模式，即对对象进行装饰。
装饰者和被装饰者，事实上同属一个父类~ 装饰者的目的是对被装饰者属性，行为进行扩充。
生动的Java代码
实现装饰模式，需要3要素：
- 抽象出共同的属性方法 interface LvHuoCommonMethods
- 被装饰者class LvHuo implements LvHuoCommonMethods
- 装饰者class XiuShiZheCaiJiao implements LvHuoCommonMethods等
上代码：
抽象出的共同属性：
/**
* LvHuoCommonMethods.java
* 驴肉火烧的基础方法
*/
public interface LvHuoCommonMethods {
public void getPeiFang();
public double getJiaGe();
}
被装饰者：
/**
* LvHuo.java
* 驴肉火烧，被修饰的类
*/
public class LvHuo implements LvHuoCommonMethods {
@Override
public double getJiaGe() {
System.out.println("基本驴肉火烧：5元");
return 5.0;
}
@Override
public void getPeiFang() {
System.out.println("火烧一个。");
System.out.println("肥瘦1两。");
}
}
装饰者菜椒：
/**
* XiuShiZheCaiJiao.java
* 修饰者菜椒
*/
public class XiuShiZheCaiJiao implements LvHuoCommonMethods {
private LvHuoCommonMethods huoshao;
public XiuShiZheCaiJiao(LvHuoCommonMethods huoshao_){
super();
this.huoshao = huoshao_;
}
@Override
public void getPeiFang(){
huoshao.getPeiFang();
System.out.println("剁两段菜椒放到火烧里。");
}
@Override
public double getJiaGe(){
double price = huoshao.getJiaGe() + 0.5;
System.out.println("菜椒另付5毛。");
return price;
}
}
装饰者焖子：
/**
* XiuShiZheMenZi.java
* 修饰者焖子
*/
public class XiuShiZheMenZi implements LvHuoCommonMethods {
private LvHuoCommonMethods huoshao;
public XiuShiZheMenZi(LvHuoCommonMethods huoshao_){
super();
this.huoshao = huoshao_;
}
@Override
public void getPeiFang(){
huoshao.getPeiFang();
System.out.println("切一片焖子剁碎放到火烧里。");
}
@Override
public double getJiaGe(){
double price = huoshao.getJiaGe() + 2;
System.out.println("焖子另付2元。");
return price;
}
}
主方法：
/**
* MainContainer.java
* 这个方法，将做火烧的顺序调换，生成了两个不同的火烧
*
* 可以尝试下
*
* 只加焖子
* 只加菜椒
*
* 多加一个修饰者咋搞，加一个修饰者肥肠试试？
*/
public class MainContainer {
public static void main(String args[]){
/* ↓↓↓*********** Important！***********↓↓↓ */
LvHuoCommonMethods lvrouhuoshao1 = new LvHuo(); //做个火烧
LvHuoCommonMethods menzihuoshao1 = new XiuShiZheMenZi(lvrouhuoshao1); //加焖子
LvHuoCommonMethods menzicaijiaohuoshao1 = new XiuShiZheCaiJiao(menzihuoshao1); //加菜椒
/* ↑↑↑*********** Important！***********↑↑↑ */
menzicaijiaohuoshao1.getPeiFang();
System.out.println("你需要付款：" + menzicaijiaohuoshao1.getJiaGe() + "元");
System.out.println();
System.out.println();
LvHuoCommonMethods lvrouhuoshao2 = new LvHuo(); //做个火烧
LvHuoCommonMethods caijiaohuoshao2 = new XiuShiZheCaiJiao(lvrouhuoshao2); //加菜椒
LvHuoCommonMethods caijiaomenzihuoshao2 = new XiuShiZheMenZi(caijiaohuoshao2); //加焖子
caijiaomenzihuoshao2.getPeiFang();
System.out.println("你需要付款：" + caijiaomenzihuoshao2.getJiaGe() + "元");
}
}
运行的结果如下：
火烧一个。 肥瘦1两。 切一片焖子剁碎放到火烧里。 剁两段菜椒放到火烧里。 基本驴肉火烧：5元 焖子另付2元。 菜椒另付5毛。 你需要付款：7.5元 火烧一个。 肥瘦1两。 剁两段菜椒放到火烧里。 切一片焖子剁碎放到火烧里。 基本驴肉火烧：5元 焖子另付2元。 菜椒另付5毛。 你需要付款：7.5元
读者如果有耐性听我BB到这里，可以再有耐心一点，加上一个修饰者肥肠~
然后在主方法里做一个 肥肠肥肠菜椒焖子肥肠火烧~
如果做出来，那么对修饰者的理解也就差不多了。本例子只对IO流进行修饰，如果被修饰的主体变成了列表、堆栈，那么可以做的事情就很多了。大型的项目里，这样的方法能极大地减轻工作量！
