（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();
    }

}

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

最后总结：
继承实现的增强类和修饰模式实现的增强类有何区别？
继承实现的增强类：
优点：代码结构清晰，而且实现简单.
缺点：对于每一个的需要增强的类都要创建具体的子类来帮助其增强，这样会导致
继承体系过于庞大。
装饰者模式实现的增强类：
优点：内部可以通过多态技术对多个需要增强的类进行增强， 可以使这些装饰类
达到互相装饰的效果。使用比较灵活。
缺点：需要内部通过多态维护需要被增强的类的实例。进而使得代码稍微复杂