建造者模式

先说下建造者模式各个角色类比。

建造者模式
1.有一个对外的统一管理者 Manger 类比：包工头  对客户来说的唯一对接人，所以代码中 只和它对接
2.抽象建造者  AbstractBuilder ,施工队，该施工队可以完成大厦各个部分的组成，如水泥，木工，钢筋工等工种 去完成对应的活。
3.具体建造者  具备完成某种建造能力的Builder 具体的某一施工队。里面 有各种建筑工人种类。
4.最终构建完成的产品Product 大厦完成所需要的组成部分。各组成部分由对应施工队完成

现在已大厦作为类比：
 完成大厦需要的零部件 假如有俩种：木头，水泥。

调用流程： 包工头接到一个工程。
          然后包工头去找了 一个施工队。施工队中有各种工种，各种工人。
          去完成对应的大厦组成部件，
          然后将部件组装起来。
          大厦完成。

 1.设计思路
 先定义大厦需要的组成部分
 把活派给包工头
 包工头找来施工队
 施工队完成大厦组成
 交付

 优点：
  代码灵活，可读性 高可以很灵活的完成复杂产品的整体的某个组成的快速迭代

  缺点
  产品过于复杂的话，可能就导致定义很多的具体建造类。

  和抽象工厂的比较  建造者模式专注于某一个产品的完整创建。
  抽象工厂是完成一系列产品的生产过程。


  在实战中 我们一般都是出于包工头的角色。

代码实战：

// 要完成的某一复杂产品
public class DaSha {

    private String mutou;

    private String shuini;

    private  String gangjin;

    public String getMutou() {
        return mutou;
    }

    public void setMutou(String mutou) {
        this.mutou = mutou;
    }

    public String getShuini() {
        return shuini;
    }

    public void setShuini(String shuini) {
        this.shuini = shuini;
    }

    public String getGangjin() {
        return gangjin;
    }

    public void setGangjin(String gangjin) {
        this.gangjin = gangjin;
    }

    @Override
    public String toString() {
        return "我完成建造了"+mutou+shuini+gangjin;
    }
}

/**
 *  抽象建造者，完成整个大厦完成 需要的的建筑能力  施工队需要具备的能力
 *  里面有各种 完成复杂产品的建造者具备的能力

/**
 * 某一施工队完成 具体的施工队
 */
public class BuilderA extends AbsractBuilder {
    @Override
    public void buildmutou() {
        daSha.setMutou("BuilderA 施工队 完成木工");
    }

    @Override
    public void buildshuini() {
        daSha.setShuini("BuilderA 施工队 完成水泥工");
    }

    @Override
    public void buildgangjin() {
        daSha.setGangjin("BuilderA 施工队 完成钢筋工");
    }
}

/**
 * 包工头统一对外接口 包工头验收交付
 */
public class Baogongtou {

    private AbsractBuilder builder;

    public Baogongtou(AbsractBuilder builders) {
        this.builder = builders;
    }

    /**
     * 包工头完成最后交付工作
     *
     * @return
     */
    public DaSha getResult() {
        builder.buildmutou();
        builder.buildshuini();
        builder.buildgangjin();
        return builder.getResult();
    }

}

　　

*/
public abstract  class AbsractBuilder {

    //创建的产品对象
    protected DaSha daSha=new DaSha();
    //木工
    public abstract void buildmutou();
    //水泥
    public abstract void buildshuini();
    //钢筋
    public abstract void buildgangjin();

    public DaSha getResult(){
        return daSha;
    }
}

/**
 * 建造者模式测试
 */
public class BuildTest {

    public static void main(String[] args) {
        Baogongtou baogongtou=new Baogongtou(new BuilderA());
        System.out.println(baogongtou.getResult().toString());
    }

}