【创建型模式 】建造者模式-java23种设计模式

介绍

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。

意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

主要解决：主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

优点：

1. 各个具体的建造者相互独立，有利于系统的扩展。
2. 客户端不必知道产品内部组成的细节，便于控制细节风险。

缺点：

1. 产品的组成部分必须相同，这限制了其使用范围。
2. 如果产品的内部变化复杂，该模式会增加很多的建造者类。

建造者（Builder）模式和工厂模式的关注点不同：建造者模式注重零部件的组装过程，而工厂方法模式更注重零部件的创建过程，但两者可以结合使用。

实现

建造者（Builder）模式的主要角色：

1. 产品角色（Product）：它是包含多个组成部件的复杂对象，由具体建造者来创建其各个部件。
2. 抽象建造者（Builder）：它是一个包含创建产品各个子部件的抽象方法的接口，通常还包含一个返回复杂产品的方法 getResult()。
3. 具体建造者(Concrete Builder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。
4. 指挥者（Director）：它调用建造者对象中的部件构造与装配方法完成复杂对象的创建，在指挥者中不涉及具体产品的信息。

代码实现:

抽象建造者

/**
 * @description 抽象建造者
 * @date 2019/8/1
 */
public abstract class Builder {

    //创建产品对象
    protected Product product=new Product();
    public abstract void buildPartA();
    public abstract void buildPartB();

    //返回产品对象
    public Product getResult()
    {
        return product;
    }
}

具体建造者实现类

/**
 * @description 具体建造者实现类A
 * @date 2019/8/1
 */
public class BuilderImplA extends Builder{

    public void buildPartA()
    {
        product.setPartA("****BuilderImplA***PartA*********");
    }
    public void buildPartB()
    {
        product.setPartB("***BuilderImplA****PartB*********");
    }
}

/**
 * @description 具体建造者实现类B
 * @date 2019/8/1
 */
public class BuilderImplB extends Builder{

    public void buildPartA()
    {
        product.setPartA("****BuilderImplB***PartA*********");
    }
    public void buildPartB()
    {
        product.setPartA("***BuilderImplB****PartB*********");
    }
}

产品类

/**
 * @description 产品
 * @date 2019/8/1
 */
public class Product {

    private String partA; //A部分
    private String partB;//B部分

    public String getPartA() {
        return partA;
    }

    public void setPartA(String partA) {
        this.partA = partA;
    }

    public String getPartB() {
        return partB;
    }

    public void setPartB(String partB) {
        this.partB = partB;
    }

    public void show()
    {
        //显示产品的特性

        System.out.println("partA : " + partA + " , partB : " +partB);
    }
}

指挥者

/**
 * @description 指挥者
 * @date 2019/8/1
 */
public class Director {

    private Builder builder;
    public Director(Builder builder)
    {
        this.builder=builder;
    }
    //产品构建与组装方法
    public Product construct()
    {
        builder.buildPartA();
        builder.buildPartB();
        return builder.getResult();
    }
}

测试

/**
 * @description 客户端
 * @date 2019/8/1
 */
public class Client {

    public static void main(String[] args)
    {
        Builder builder=new BuilderImplA();
        Director director=new Director(builder);
        Product product=director.construct();
        product.show();
    }
}

总结

建造者（Builder）模式创建的是复杂对象，其产品的各个部分经常面临着剧烈的变化，但将它们组合在一起的算法却相对稳定，所以它通常在以下场合使用。

• 创建的对象较复杂，由多个部件构成，各部件面临着复杂的变化，但构件间的建造顺序是稳定的。
• 创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式，即产品的构建过程和最终的表示是独立的。