设计模式之建造者模式(BuilderPattern)

代码实现
我们来构建上述的角色，实现建造者模式:

首先，先定义产品，我们以电脑产品为例，建造者模式的产品以类为主，注重的是内部的部件(成员属性):

复制代码
/**

• 产品:电脑
  /
  public class Computer {
  /*

  • 内部部件:
    */
    private String brand;
    private String cpu;
    private String mainBoard;
    private String hardDisk;
    private String displayCard;
    private String power;
    private String memory;

  public String getBrand() {
  return brand;
  }

  public void setBrand(String brand) {
  this.brand = brand;
  }

  public String getCpu() {
  return cpu;
  }

  public void setCpu(String cpu) {
  this.cpu = cpu;
  }

  public String getMainBoard() {
  return mainBoard;
  }

  public void setMainBoard(String mainBoard) {
  this.mainBoard = mainBoard;
  }

  public String getHardDisk() {
  return hardDisk;
  }

  public void setHardDisk(String hardDisk) {
  this.hardDisk = hardDisk;
  }

  public String getDisplayCard() {
  return displayCard;
  }

  public void setDisplayCard(String displayCard) {
  this.displayCard = displayCard;
  }

  public String getPower() {
  return power;
  }

  public void setPower(String power) {
  this.power = power;
  }

  public String getMemory() {
  return memory;
  }

  public void setMemory(String memory) {
  this.memory = memory;
  }
  }
  复制代码

然后，我们定义抽象创建者，主要分为两部分:buildX构建部件，和getResult获取构建产品,代码如下:

复制代码
**

• 建造者角色，其实就是代替复杂对象的构造函数等构造方式，在这里对复杂对象进行构建
  */
  public abstract class ComputerBuilder {
  //建造者中，创建复杂产品对象，构建出复杂对象后，进行输出。
  protected Computer computer = new Computer();

  /**

  • 建造产品部件的方法，这里用抽象方法，不同的建造者可以构建出不同的产品部件来。
    */
    public abstract void buildBrand();
    public abstract void buildCPU();
    public abstract void buildMainBoard();
    public abstract void buildHardDisk();
    public abstract void buildDisplayCard();
    public abstract void buildPower();
    public abstract void buildMemory();

  /**

  • 建造者最后输出复杂产品。
  • @return
    */
    public Computer createComputer() {
    return computer;
    }
    }
    复制代码

然后创建具体建造者类，如下代码：

复制代码
/**

• 具体建造者，可以构建不同的产品部件。构建者有统一的构建接口，这样可以规范不同构建者。
  */
  public class ASUSComputerBuilder extends ComputerBuilder{
  @Override
  public void buildBrand() {
  computer.setBrand(“华硕电脑”);
  }

  @Override
  public void buildCPU() {
  computer.setCpu(“Intel 第8代 酷睿”);
  }

  @Override
  public void buildMainBoard() {
  computer.setMainBoard(“华硕主板”);
  }

  @Override
  public void buildHardDisk() {
  computer.setHardDisk(“256GB SSD”);
  }

  @Override
  public void buildDisplayCard() {
  computer.setDisplayCard(“MX150 独立2GB”);
  }

  @Override
  public void buildPower() {
  computer.setPower(“3芯 锂离子电池 65W AC适配器”);
  }

  @Override
  public void buildMemory() {
  computer.setMemory(“1 x SO-DIMM 8GB”);
  }
  }
  复制代码
  复制代码
  /**

• 具体建造者，可以构建不同的产品部件。构建者有统一的构建接口，这样可以规范不同构建者。
  */
  public class DellComputerBuilder extends ComputerBuilder {
  @Override
  public void buildBrand() {
  computer.setBrand(“戴尔电脑”);
  }

  @Override
  public void buildCPU() {
  computer.setCpu(“i5-8300H 四核”);
  }

  @Override
  public void buildMainBoard() {
  computer.setMainBoard(“戴尔主板”);

  }

  @Override
  public void buildHardDisk() {
  computer.setHardDisk(“1T + 128GB SSD”);
  }

  @Override
  public void buildDisplayCard() {
  computer.setDisplayCard(“GTX1060 独立6GB”);

  }

  @Override
  public void buildPower() {
  computer.setPower(“4芯 锂离子电池 180W AC适配器”);
  }

  @Override
  public void buildMemory() {
  computer.setMemory(“4G + 4G”);
  }
  }
  复制代码

然后，我们定义导演类，来调度建造者，输出复杂产品:

复制代码
/**

• 导演类，指挥构建过程，调用建造者类。
  /
  public class ComputerDirector {
  /*

  • 导演类的建造方法一般都用construct命名。传入具体建造者类，输出产品
  • @param builder
  • @return
    */
    public Computer construct(ComputerBuilder builder){
    Computer computer;
    builder.buildBrand();
    builder.buildCPU();
    builder.buildDisplayCard();
    builder.buildHardDisk();
    builder.buildMainBoard();
    builder.buildMemory();
    builder.buildPower();
    computer = builder.createComputer();
    return computer;

  }
  }
  复制代码

这样，对于业务程序员而言，就可以通过导演类，来获取复杂对象了，如下:

复制代码
public class Main {
public static void main(String[] args) {
//用户直接使用的是导演类
ComputerDirector director=new ComputerDirector();
//选择相应的构建者，来构建不同的部件
ComputerBuilder dellBuilder = new DellComputerBuilder();
//返回构建出来的产品
Computer dellComputer=director.construct(dellBuilder);

}

}
Wooden Speakers https://www.zeshuiplatform.com/