建造者设计模式

建造者设计模式（BuilderPattern）

描述： 首先建造者设计模式是用来构建复杂的对象的，它主要强调的是当对于一个复杂对象的构建，比如当一个类的构造函数的参数超过4个的时候，且都是可变参数时侯考虑使用建造者设计模式。

核心思想: 当你的一个类需要很多的参数来构建时就可以把这些参数提取出来放在另一个类中进行构建

建造者设计模式的优点：

封装性
独立，易于扩展
便于控制细节风险，对建造过程逐步细化

建造者设计模式的使用场景：

-　相同的方法，不同的执行顺序产生不同的结果
-　多个零件或者部件，可以配置到多个对象中产生不同的效果
-　产品类中调用的顺序不同会产生不同的结果

示例:

构建制茶模型


abstract class TeaModel {
    public abstract void caiZhai();

    public abstract void weiTiao();

    public abstract void hunGan();

    public abstract void nianRou();

    public abstract void faJiao();

    public abstract void ganZao();

    public abstract void baoCun();

    private List<String> list = new ArrayList<String>();

    public void setCourse(ArrayList<String> list) {
        this.list = list;
    }

    public void buildTea() {
        list.forEach(x -> {
            switch (x) {
                case "采摘":
                    this.caiZhai();
                    break;
                case "萎调":
                    this.weiTiao();
                    break;
                case "烘干":
                    this.hunGan();
                    break;
                case "保存":
                    this.baoCun();
                    break;
                case "干燥":
                    this.ganZao();
                    break;
                case "发酵":
                    this.faJiao();
                    break;
                case "揉捻":
                    this.nianRou();
                    break;
                default:
                    System.out.println("未知的操作");
                    break;
            }
        });
    }

}

红茶实现模型

class BlackTeaModel extends TeaModel {

    @Override
    public void caiZhai() {
        System.out.println("红茶：采摘");

    }

    @Override
    public void weiTiao() {
        System.out.println("红茶：萎调");

    }

    @Override
    public void hunGan() {
        System.out.println("红茶：烘干");

    }

    @Override
    public void nianRou() {
        System.out.println("红茶：揉捻");

    }

    @Override
    public void faJiao() {
        System.out.println("红茶：发酵");
    }

    @Override
    public void ganZao() {
        System.out.println("红茶：干燥");
    }

    @Override
    public void baoCun() {
        System.out.println("红茶： 保存");
    }
}

抽象制茶的建造者

abstract class AbstractTeaBuild {

    /**
     * 设置调制茶的顺序
     *
     * @param list
     */
    public abstract void setCourse(ArrayList<String> list);
     
    
    /**
     * 获取茶叶
     *
     */
    public abstract TeaModel getTea();
}

具体茶叶的建造者

class BlackTeaBuilder extends AbstractTeaBuild {
    /**
     * 红茶的构建者
     */
    private TeaModel tm = new BlackTeaModel();

    @Override
    public void setCourse(ArrayList<String> list) {
        tm.setCourse(list);
    }

    @Override
    public TeaModel getTea() {
        return tm;
    }
}

调制茶叶

class TeaMakeDirector {
    private AbstractTeaBuild ab = new BlackTeaBuilder();
    private ArrayList<String> list = new ArrayList();

    //制作红茶 红茶制作工序 ：采摘 → 萎调 → 揉捻 → 发酵 → 干燥
    public BlackTeaModel getBlackTea() {
        list.clear();
        list.add("采摘");
        list.add("萎调");
        list.add("揉捻");
        list.add("发酵");
        list.add("干燥");
        ab.setCourse(list);
        return (BlackTeaModel) ab.getTea();
    }

}

需求来了要三个红茶

public class test {
    //来三杯绿茶
    public static void main(String[] args) {
        TeaMakeDirector teaMakeDirector = new TeaMakeDirector();
        for (int i = 0; i <= 2; i++){
            teaMakeDirector.getBlackTea().buildTea();
            System.out.println("第"+i+ "杯红茶已好");
        }
    }
}

总结:

建造者设计模式UML

product就是最终要生成的对象例如:(BlackTeaModel)

Builde就是建造者的抽象基类例如:( AbstractTeaBuild )

ConcreteBuilde实现 Builde 例如:( BlackTeaBuilder)

Director: 决定如何构建最终产品的算法. 其会包含一个负责组装的方法(getBlackTea) 调用这个方法就相当于组装好了一个产品例如(TeaMakeDirector)

建造者设计模式 （BuilderPattern）

建造者设计模式（BuilderPattern）