看我七十二变

有近2星期没有写文章了，各种原因吧，主要是懒。

今天接着写吧，今天写一个孙悟空的七十二变。

变树、变房、变小女孩

我们会用到装饰模式，装饰模式是结构型设计模式的一种。

装饰模式也可以叫包装(Wrapper)模式，我对他的理解就是他替代了继承操作。

比如我们写一个孙悟空七十二变的例子，用继承是这么做的：

代码很简单就不写了，类图是这样子的

• 抽象构件（Component)角色：这是一个抽象接口，用以规范准备附加责任的对象
• 具体构件（ConcreteComponent)角色：这是一个具体的准备接受附加责任的对象
• 装饰（Decorator）角色：这是一个抽象修饰类，他持有一个Component对象
• 具体装饰（ConcreteDecorator）角色：负责给持有对象Component附加责任

那具体到我们这个七十二变的例子中类图是什么样的呢？

注意：不要太在意这里的继承和实现，我们开发中可以用抽象类子类继承，也可以用接口然后编写实现

取经人：

package decorate;


public interface BibleReader {
    void change();
}

猪八戒、孙悟空：

package decorate;


public class SunWuKong implements BibleReader{

    @Override
    public void change() {
        System.out.print("孙悟空");
    }
}

package decorate;


public class ZhuBaJie implements BibleReader{

    @Override
    public void change() {
        System.out.print("猪八戒");
    }
}

装饰类：

package decorate;



public  abstract class Decorator implements BibleReader {
    BibleReader bb ;
    public Decorator(BibleReader bb) {
        this.bb = bb;
    }

    @Override
    public void change(){
        if (bb != null) {
            bb.change();
        }
    }
}

装饰变树：

package decorate;


public class TreeDecorator extends Decorator{

    public TreeDecorator(BibleReader bb) {
        super(bb);
    }
    // 独有的装饰方式
    private void myDecorator(){
        System.out.println("--变树！！");
    }

    @Override
    public void change(){
        if (bb != null) {
            bb.change();
        }
        myDecorator();
    }
}

装饰变房子：

package decorate;


public class HouseDecorator extends Decorator{

    public HouseDecorator(BibleReader bb) {
        super(bb);
    }
    // 独有的装饰方式
    private void myDecorator(){
        System.out.println("--变房子！！");
    }

    @Override
    public void change(){
        if (bb != null) {
            bb.change();
        }
        myDecorator();
    }
}

装饰变小女孩：

package decorate;


public class GirlDecorator extends Decorator{

    public GirlDecorator(BibleReader bb) {
        super(bb);
    }
    // 独有的装饰方式
    private void myDecorator(){
        System.out.println("--变小女孩！！");
    }

    @Override
    public void change(){
        if (bb != null) {
            bb.change();
        }
        myDecorator();
    }
}

开始变：

package decorate;


public class TestChange {
    public static void main(String[] args) {

        // 孙悟空本空
        SunWuKong sunWuKong = new SunWuKong();
        // 猪八戒本猪
        ZhuBaJie zhuBaJie = new ZhuBaJie();

        // 孙悟空变小女孩装饰类
        GirlDecorator girlDecorator = new GirlDecorator(sunWuKong);
        girlDecorator.change();

        // 孙悟空变房子装饰类
        HouseDecorator houseDecorator = new HouseDecorator(sunWuKong);
        houseDecorator.change();

        // 猪八戒变小女孩
        GirlDecorator girlDecoratorZhuBajie = new GirlDecorator(zhuBaJie);
        girlDecoratorZhuBajie.change();

        // 猪八戒变树
        TreeDecorator treeDecorator = new TreeDecorator(zhuBaJie);
        treeDecorator.change();
    }
}

这时候如果沙悟净也想变，那我们只需要定义一个BibleReader的子类，然后就可以给他装饰各种变换

不用再针对每种变换再定义子类。

这就是我开头说的，我理解装饰就是用聚合代替了继承

看到这里是不是觉得它很像代理模式，桥接模式？

是的！

等你全部领悟了之后，可以达到心中无剑手中有剑，也就是你没想着用某种设计模式，但是你写出来的代码已经符合了某种设计模式。

比如： 1+1=2

比如：有人伸手打你，你会出手阻挡

比如：时间到了10点50 ，你就拿手机定外卖