（java）从零开始之--装饰者设计模式

装饰者设计模式：
简单定义：增强一个类的功能，而且还可以让这些装饰类互相装饰。

应用场景：当要在某个功能的基础上扩充功能，并且扩充的功能具有大量排列组合，通过继承关系会衍生出大量子类，这时候用装饰者模式来解决。

装饰者设计模式的步骤：
1. 在装饰类的内部维护一个被装饰类的引用。
2. 让装饰类有一个共同的父类或者是父接口。

例如：人有一种行为叫“吃水果”，其中水果有4种：苹果、香蕉、鸭梨、橘子
现在有需求如下：
A类人行为：吃苹果
B类人行为：先吃苹果，再吃香蕉
C类人行为：先吃香蕉，再吃苹果
D类人行为：先吃橘子，后吃鸭梨

我们先用子类继承来实现：代码如下

 interface IEatFruit{
 public void eatFruit();
 }

 class PersonA implements IEatFruit{

 　　@Override
 　　public void eatFruit() {
 　　　　System.out.println("吃苹果");
 　　}

 }
 class PersonB implements IEatFruit{

 @Override
 　　public void eatFruit() {
 　　　　System.out.println("吃苹果");
 　　　　System.out.println("吃香蕉");
 　　}

 }
 class PersonC implements IEatFruit{

 　　@Override
 　　public void eatFruit() {
 　　　　System.out.println("吃香蕉");
 　　　　System.out.println("吃苹果");
 　　}

 }
 class PersonD implements IEatFruit{

 　　@Override
 　　public void eatFruit() {
 　　　　System.out.println("吃橘子");
 　　　　System.out.println("吃鸭梨");
 　　}

 }

这样当然是没问题的，每一类人对应new出来的对象 都可以实现对应的需求。
但是，当需求改为：
某类人行为：吃上面四种水果，并且要求有先后顺序
这样的排列组合有24种....
这样你还会用继承去做吗？写24个子类去实现接口，明显不合适。
这时候如果用到装饰者模式，代码则会变成：

 interface IEatFruit{
     public void eatFruit();
 }

 class PersonA implements IEatFruit{
     IEatFruit eat;
     public PersonA(){
         this.eat = this;
     }
     public PersonA(IEatFruit _eat){
         this.eat = _eat;
     }
     @Override
     public void eatFruit() {
         if(!(this.eat instanceof PersonA)){
             this.eat.eatFruit();
             System.out.println("吃苹果");
         }else{
             System.out.println("吃苹果");
         }
     }

 }
 class PersonB implements IEatFruit{
     IEatFruit eat;
     public PersonB(){
         this.eat = this;
     }
     public PersonB(IEatFruit _eat){
         this.eat = _eat;
     }
     @Override
     public void eatFruit() {
         if(!(this.eat instanceof PersonB)){
             this.eat.eatFruit();
             System.out.println("吃香蕉");
         }else{
             System.out.println("吃香蕉");
         }
     }

 }
 class PersonC implements IEatFruit{
     IEatFruit eat;
     public PersonC(){
         this.eat = this;
     }
     public PersonC(IEatFruit _eat){
         this.eat = _eat;
     }
     @Override
     public void eatFruit() {
         if(!(this.eat instanceof PersonC)){
             this.eat.eatFruit();
             System.out.println("吃鸭梨");
         }else{
             System.out.println("吃鸭梨");
         }
     }

 }
 class PersonD implements IEatFruit{
     IEatFruit eat;
     public PersonD(){
         this.eat = this;
     }
     public PersonD(IEatFruit _eat){
         this.eat = _eat;
     }
     @Override
     public void eatFruit() {
         if(!(this.eat instanceof PersonD)){
             this.eat.eatFruit();
             System.out.println("吃橘子");
         }else{
             System.out.println("吃橘子");
         }
     }

 }

 public class Demo2 {

     public static void main(String[] args) {
         //这样就可以通过上述4类人来相互装饰，就可以随意任意一种组合“吃水果”
         //如：吃橘子->吃苹果
         PersonD d = new PersonD();
         PersonA a = new PersonA(d);
         a.eatFruit();
         System.out.println("-------我是分割线------------");
         //如：吃苹果->吃橘子->吃鸭梨->吃香蕉
         PersonA a2 = new PersonA();
         PersonD d2 = new PersonD(a2);
         PersonC c2 = new PersonC(d2);
         PersonB b2 = new PersonB(c2);
         b2.eatFruit();
     }

 }

输出结果如下：
吃橘子
吃苹果
-------我是分割线------------
吃苹果
吃橘子
吃鸭梨
吃香蕉

最后总结：
继承实现的增强类和修饰模式实现的增强类有何区别？
继承实现的增强类：
优点：代码结构清晰，而且实现简单.
缺点：对于每一个的需要增强的类都要创建具体的子类来帮助其增强，这样会导致

继承体系过于庞大。
装饰者模式实现的增强类：
优点：内部可以通过多态技术对多个需要增强的类进行增强， 可以使这些装饰类

达到互相装饰的效果。使用比较灵活。
缺点：需要内部通过多态维护需要被增强的类的实例。进而使得代码稍微复杂