设计模式之趣说建造者模式

建造者模式概述

创建和构造进行分离

常用于常见复杂的对象，可以在用户不清楚的情况下进行创建。

产品
首先写产品的相关功能

 public class Product {
    //地基
    private String buildA;
    //钢筋
    private String buildB;
    //电线
    private String buildC;
    //粉刷
    private String buildD;
    //getter  setter toString
 }

抽象的建造者，类似于图纸，规定某些方法

public abstract class Build {
    //建造地基
    abstract void buildA();
    //建造钢筋
    abstract void buildB();
    //建造电线
    abstract void buildC();
    //进行粉刷
    abstract void buildD();
    //最终产生产品
    abstract  Product getProduct();
}

这是是由指挥者进行指挥，可以由不同的工人进行实现
工人实现图纸的方法

public class WorkA extends Build {
    //最终构建的产品
    private Product product;

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

    @Override
    void buildA() {
        product.setBuildA("正在进行地基");
        System.out.println(product);

    }

    @Override
    void buildB() {
        product.setBuildB("正在进行钢筋");
        System.out.println(product);
    }

    @Override
    void buildC() {
        product.setBuildC("水电");
        System.out.println(product);
    }

    @Override
    void buildD() {
        product.setBuildD("粉刷");
        System.out.println(product);
    }

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

指挥者，关系着建造的步骤，产品建造成什么样起决定性作用
类似于包工头

public class Director {

    //指挥工人建造房子
    public Product buildProduct(Build build){
        build.buildA();
        build.buildB();
        build.buildC();
        build.buildD();
        //最终得到产品
        return build.getProduct();
    }
}

面向用户的接口

public static void main(String[] args) {
		//找一个建造者
        Director director = new Director();
        //建造着找的工人建造
        Product product = director.buildProduct(new WorkA());
        System.out.println(product);
    }

最终得到了成品product
通常指挥者是我们自己，指挥得到想要的产品效果，通过静态内部类的方式进行改善。

代码的改善。此时没有指挥者，工人的话就可以当作指挥者
产品

public class Product {
    //代表最终的产品，默认是面包和可乐
    private String A = "面包";
    private String B = "可乐";
   //setter,getter和toString省略
}

抽象的建造者

public abstract class Build {

    abstract void buildA(String str);
    abstract void buildB(String str);
    abstract Product getProduct();
}

执行者
由于没了指挥者，该执行者也可以改变顺序,可以改变产品

//类似于服务员
public class Worker extends Build {

    private Product product;

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

    @Override
    void buildA(String str) {
        product.setA(str);
    }

    @Override
    void buildB(String str) {
        product.setB(str);
    }

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

面向用户的是执行者，由于没了指导者，用户可以为指导者

public static void main(String[] args) {
       //服务员
       Worker worker = new Worker();
       //默认生产套餐
       System.out.println(worker.getProduct());
       //自定义套餐
       worker.buildA("一个披萨");
       worker.buildB("一个咖啡");
       System.out.println(worker.getProduct());
      // 结果
     Product{A='面包', B='可乐'}
      Product{A='一个披萨', B='一个咖啡'}
   }