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

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

建造者模式（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分支

 

应用：

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

转载于:https://www.cnblogs.com/sleepy-goblin/p/10125559.html