温故而知新 03建造者模式的实现回顾

需求：创建复杂的对象---通过简单的对象的自由组合，返回一个完整的产品。

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

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

何时使用：一些基本部件不会变，而其组合经常变化的时候。

如何解决：将变与不变分离开。

关键代码：建造者：创建和提供实例，导演：管理建造出来的实例的依赖关系。

最基础代码思路：

创建一个抽象类的建造者 用来定义生产 哪些模块

package cn.xzc.test.builderMode;


/*
* 建造者模式  创建者模式的一种
* 复杂的类通过 简单的类 组合而来
*
*
* */
public abstract class Builder {
    abstract  void BuildeA();
    abstract  void BuildeB();
    abstract  void BuildeC();
    abstract  void BuildeD();
    abstract Product getProduct();
}

 

创建产品

 

public class Product {
    private  String buildA;
    private  String buildB;
    private  String buildC;
    private  String buildD;

    public String getBuildA() {
        return buildA;
    }

    public void setBuildA(String buildA) {
        this.buildA = buildA;
    }

    public String getBuildB() {
        return buildB;
    }

    public void setBuildB(String buildB) {
        this.buildB = buildB;
    }

    public String getBuildC() {
        return buildC;
    }

    public void setBuildC(String buildC) {
        this.buildC = buildC;
    }

    public String getBuildD() {
        return buildD;
    }

    public void setBuildD(String buildD) {
        this.buildD = buildD;
    }

    @Override
    public String toString() {
        return "product{" +
                "buildA='" + buildA + '\'' +
                ", buildB='" + buildB + '\'' +
                ", buildC='" + buildC + '\'' +
                ", buildD='" + buildD + '\'' +
                '}';
    }
}

 

建造一个工作者集成抽象类建造者用来实际生产产品

package cn.xzc.test.builderMode02.demo01;

public class Worker extends Builder{
    private Product product;

    public Worker() {
        product = new Product();
    }

    @Override
    void BuildeA() {
        product.setBuildA("A");
        System.out.println(product.getBuildA());
    }

    @Override
    void BuildeB() {
        product.setBuildB("B");
        System.out.println(product.getBuildB());
    }

    @Override
    void BuildeC() {
        product.setBuildC("C");
        System.out.println(product.getBuildC());
    }

    @Override
    void BuildeD() {
        product.setBuildD("D");
        System.out.println(product.getBuildD());
    }

    @Override
    Product getProduct(){
       return product;
    }
}

建造一个指挥者来控制生产者去生产产品

package cn.xzc.test.builderMode02.demo01;

/*
* 指挥  核心  指定生产者按一定顺序去建造出产品
* */
public class Director {
    public Product build(Builder builder){
        builder.BuildeA();
        builder.BuildeB();
        builder.BuildeC();
        builder.BuildeD();

        return builder.getProduct();
    }
}

 

最后测试‘

public class TestForBuildMode {
    public static void main(String[] args) {
        Director director= new Director();
        Product build= director.build(new Worker());
        System.out.println(build);
    }

}

 

进阶思考

通常我们的建造顺序不需要写死，建造的内容也需要传参来决定，用户作为调用者自己决定顺序和具体传入参数。

改造建造者可以传入参数 和返回参数

/*
* 建造者模式  创建者模式的一种
* 复杂的类通过 简单的类 组合而来
*
*  添加传入参数和返回值
*
* */
public abstract class Builder {
    abstract  Builder BuildeA(String msg);
    abstract  Builder BuildeB(String msg);
    abstract  Builder BuildeC(String msg);
    abstract  Builder BuildeD(String msg);
    abstract Product getProduct();
}

 

改造工作者 继承的建造者建造产品的方法返回this 实现链式编程

/*
* 实现工人类来执行产品生产 返回值为this 实现链式编程
* */
public class Worker extends Builder {
    private Product product;

    public Worker() {
        product = new Product();
    }


    @Override
    Builder BuildeA(String msg) {
        product.setBuildA(msg);
        return this;
    }
    @Override
    Builder BuildeB(String msg) {
        product.setBuildB(msg);
        return this;
    }

    @Override
    Builder BuildeC(String msg) {
        product.setBuildC(msg);
        return this;
    }

    @Override
    Builder BuildeD(String msg) {
        product.setBuildD(msg);
        return this;
    }

    @Override
    Product getProduct(){
       return product;
    }
}

产品给默认参数 同时可接受工作者传参

package cn.xzc.test.builderMode02.demo02;

public class Product {
    private  String buildA = "A1";
    private  String buildB = "B1";
    private  String buildC = "C1";
    private  String buildD = "D1";

    public String getBuildA() {
        return buildA;
    }

    public void setBuildA(String buildA) {
        this.buildA = buildA;
    }

    public String getBuildB() {
        return buildB;
    }

    public void setBuildB(String buildB) {
        this.buildB = buildB;
    }

    public String getBuildC() {
        return buildC;
    }

    public void setBuildC(String buildC) {
        this.buildC = buildC;
    }

    public String getBuildD() {
        return buildD;
    }

    public void setBuildD(String buildD) {
        this.buildD = buildD;
    }

    @Override
    public String toString() {
        return "product{" +
                "buildA='" + buildA + '\'' +
                ", buildB='" + buildB + '\'' +
                ", buildC='" + buildC + '\'' +
                ", buildD='" + buildD + '\'' +
                '}';
    }
}

 

最后测试

public class TestForBuildMode {
    public static void main(String[] args) {
        Worker worker= new Worker();
        Product product = worker.BuildeA("f").BuildeD("g").BuildeC("c").getProduct();
        System.out.println(product.toString());
    }
}