设计模式------建造者模式

大话设计模式学习笔记 - 建造者模式

建造者模式（Builder）：将一个复杂对象的构建与它的表示分离，使得一样的构建过程能够建立多个不一样的表示。

　　建造者模式能够将一个产品的表象展现与产品的生成过程分离，从而使一个建造过程生成具备不一样的内部表象的产品对象。若是使用了建造者模式，那么就只须要指定须要建造的类型就能够获得他们，而具体的建造过程和细节就不须要知道了。

建造者模式结构图以下：

说明：

　　建造者模式主要用于建立一些复杂的对象，这些对象内部构建间的建造顺序一般是稳定的，但对象内部的构建一般面临着复杂的变化。

　　建造者模式的好处是使建造代码与表示代码分离，因为建造者隐藏了该产品是如何组装的，因此若须要改变一个产品的内部表示，只须要再定义一个具体的建造者（ConcreateBuilder）就能够。

示例代码：

　　例：假设有一个画小人的需求，需求中有可能须要各类各样的小人，好比瘦的，胖的，高的，矮的，丑的，漂亮的。。。。

　　因为这个比较简单，代码中没有写过多的注释。具体代码下面有git地址，能够下载到本地尝试，一看就懂。

　　产品类：即小人

public class PersonProduct {
    private String head;
    private String body;
    private String leftArm;
    private String rightArm;
    private String leftLeg;
    private String rightLeg;

    /**
     * 展现全部产品
     */
    public void show(){
        System.out.println("当前产品为：" + this.toString());
    }
}
建造者抽象类：即builder，建立小人的通用步骤

public abstract class PersonBuilder {

    public String head;
    public String body;
    public String leftArm;
    public String rightArm;
    public String leftLeg;
    public String rightLeg;

    public PersonBuilder(String head, String body, String leftArm, String rightArm, String leftLeg, String rightLeg) {
        this.head = head;
        this.body = body;
        this.leftArm = leftArm;
        this.rightArm = rightArm;
        this.leftLeg = leftLeg;
        this.rightLeg = rightLeg;
    }

    /**
     * 建立小人的头
     * @param head 头
     */
    public abstract void buildHead(String head);

    /**
     * 建立小人的身体
     * @param body 身体
     */
    public abstract void buildBody(String body);

    /**
     * 建立左臂
     * @param leftArm 左臂
     */
    public abstract void buildLeftArm(String leftArm);

    /**
     * 建立右臂
     * @param rightArm 右臂
     */
    public abstract void buildRightArm(String rightArm);

    /**
     * 建立左腿
     * @param leftLeg 左腿
     */
    public abstract void buildLeftLeg(String leftLeg);

    /**
     * 建立右腿
     * @param rightLeg 右腿
     */
    public abstract void buildRightLeg(String rightLeg);

    /**
     * 得到建造以后的结果
     * @return
     */
    public abstract PersonProduct getProduct();

}
建造瘦小人的具体建立类：即concreate

public class ThinPersonBuilder extends PersonBuilder {

    private final String thinPerson = "建造瘦小人：";
    private PersonProduct product = new PersonProduct();

    public ThinPersonBuilder(String head, String body, String leftArm, String rightArm, String leftLeg, String rightLeg) {
        super(head, body, leftArm, rightArm, leftLeg, rightLeg);
    }

    @Override
    public void buildHead(String head) {
        System.out.println(thinPerson + head);

    }

    @Override
    public void buildBody(String body) {
        System.out.println(thinPerson + body);
        product.setBody(body);
    }

    @Override
    public void buildLeftArm(String leftArm) {
        System.out.println(thinPerson + leftArm);
        product.setLeftArm(leftArm);
    }

    @Override
    public void buildRightArm(String rightArm) {
        System.out.println(thinPerson + rightArm);
        product.setRightArm(rightArm);
    }

    @Override
    public void buildLeftLeg(String leftLeg) {
        System.out.println(thinPerson + leftLeg);
        product.setLeftLeg(leftLeg);
    }

    @Override
    public void buildRightLeg(String rightLeg) {
        System.out.println(thinPerson + rightLeg);
        product.setRightLeg(rightLeg);
    }

    @Override
    public PersonProduct getProduct() {
        return product;
    }
}
胖小人具体建造类

public class FatPersonBuilder extends PersonBuilder {

    private final String fatPerson = "建造胖小人：";

    public FatPersonBuilder(String head, String body, String leftArm, String rightArm, String leftLeg, String rightLeg) {
        super(head, body, leftArm, rightArm, leftLeg, rightLeg);
    }
    private PersonProduct product = new PersonProduct();

    @Override
    public void buildHead(String head) {
        System.out.println(fatPerson + head);
        product.setHead(head);
    }

    @Override
    public void buildBody(String body) {
        System.out.println(fatPerson + body);
        product.setBody(body);
    }

    @Override
    public void buildLeftArm(String leftArm) {
        System.out.println(fatPerson + leftArm);
        product.setLeftArm(leftArm);
    }

    @Override
    public void buildRightArm(String rightArm) {
        System.out.println(fatPerson + rightArm);
        product.setRightArm(rightArm);
    }

    @Override
    public void buildLeftLeg(String leftLeg) {
        System.out.println(fatPerson + leftLeg);
        product.setLeftLeg(leftLeg);
    }

    @Override
    public void buildRightLeg(String rightLeg) {
        System.out.println(fatPerson + rightLeg);
        product.setRightLeg(rightLeg);
    }

    @Override
    public PersonProduct getProduct() {
        return product;
    }
}
执行者类：即director

public class PersonDirector {
    
    public void createPerson(PersonBuilder builder){
        builder.buildHead(builder.head);
        builder.buildBody(builder.body);
        builder.buildLeftArm(builder.leftArm);
        builder.buildRightArm(builder.rightArm);
        builder.buildLeftLeg(builder.leftLeg);
        builder.buildRightLeg(builder.rightLeg);
    }
}
客户端实现：

public class BuilderApplication {

    public static void main(String[] args) {
        ThinPersonBuilder thinPersonBuilder = new ThinPersonBuilder("thinHead","thinBody","thinLeftArm",
                                                                    "thinRightArm","thinLeftLeg","thinRightLeg");
        FatPersonBuilder fatPersonBuilder = new FatPersonBuilder("thinHead","thinBody","thinLeftArm",
                "thinRightArm","thinLeftLeg","thinRightLeg");
        PersonDirector director = new PersonDirector();

        director.createPerson(thinPersonBuilder);
        PersonProduct thinProduct = thinPersonBuilder.getProduct();
        thinProduct.show();

        director.createPerson(fatPersonBuilder);
        PersonProduct fatProduct = fatPersonBuilder.getProduct();
        fatProduct.show();
    }

}

　　git地址：https://gitee.com/Gggoblin/design.pattern.git                         builder分支

 

应用：

　　建造者模式是在当建立复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时适用的模式。