建造者模式

• 定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示
  • 有如下角色：

     

    • Director：导演类，负责安排已有模块的顺序，然后通知Builder开始建造
    • Builder: 抽象Builder类，规范产品组建，一般由子类实现
    • ConcreteBuilder：具体建造者，实现抽象Builder类定义的所有方法，并返回一个组建好的对象
    • Product：产品类

 

• 建造者模式的简单实现：
• 产品类：

  public class Computer {
      private String mCpu;
      private String mMainBoard;
      private String mRam;
  
  
  
      public void setmCpu(String mCpu) {
          this.mCpu = mCpu;
      }
  
  
      public void setmMainBoard(String mMainBoard) {
          this.mMainBoard = mMainBoard;
      }
  
  
  
      public void setmRam(String mRam) {
          this.mRam = mRam;
      }
  
      @Override
      public String toString() {
          return "Computer{" +
                  "mCpu='" + mCpu + '\'' +
                  ", mMainBoard='" + mMainBoard + '\'' +
                  ", mRam='" + mRam + '\'' +
                  '}';
      }
  }
  

  　　

• 创建Builder类规范产品的组建

  **
   * aaa
   * Created by lzw on 2018/6/5. 09:49:59
   * 邮箱：632393724@qq.com
   * 定义：创建复杂对象的创建型模式，将其构建复杂对象的过程和它的部件解耦，使得构建过程和部件的表示（产品）
   * 分离出来
   * 功能：构建一个Computer产品类
   * All Rights Saved! Chongqing AnYun Tech co. LTD
   */
  public abstract class Builder {
      protected abstract void buildCpu(String cpu);
      protected abstract void buildMainBoard(String mainBoard);
      protected abstract void buildRam(String mRam);
      public abstract Computer create();
  }
  

  　　

• 实现抽象的builder类

  public class MoonComputerBuilder extends Builder {
  
      private Computer mComputer = new Computer();
  
      @Override
      protected void buildCpu(String cpu) {
          mComputer.setmCpu(cpu);
      }
  
      @Override
      protected void buildMainBoard(String mainBoard) {
          mComputer.setmMainBoard(mainBoard);
      }
  
      @Override
      protected void buildRam(String mRam) {
          mComputer.setmRam(mRam);
      }
  
      @Override
      public Computer create() {
          return mComputer;
      }
  }
  

  　　

• 用导演类统一组装过程

  public class Director {
      Builder builder = null;
  
      public Director(Builder builder) {
          this.builder = builder;
      }
  
      public Computer createComputer(String cpu,String mainBoard, String ram){
          //规范建造流程
          this.builder.buildMainBoard(mainBoard);
          this.builder.buildCpu(cpu);
          this.builder.buildRam(ram);
          return this.builder.create();
      }
  }
  

  　　

• 客户端调用导演类

  public class ClientCreateComputer {
      public static void main(String[] args){
          Builder builder = new MoonComputerBuilder();
          Director director = new Director(builder);
          Computer computer = director.createComputer("i7-6000","华擎玩家至尊","三星DDR4");
      }
  }
  

 

 

• 使用建造者模式的场景和优缺点
  • 使用场景：
    • 当创建复杂对象的算法应该独立于该对象的组成部分以及他们的装配方式时
    • 相同的方法，不同的执行顺序，产生不同的事件结果时
    • 多个部件或零个部件都可以装配到一个对象中，但是产生的运行结果又不相同时
    • 产品类非常复杂，或者产品类中的调用顺序不同而产生了不同的效能
    • 在创建一些复杂的对象时，这些对象的内部组成构件间的建造顺序是稳定的，但是对象的内部组成构件面临着复杂的变化

 

• • 优点：
    • 使用建造者模式可以不关心产品内部组成细节
    • 具体的建造者类之间是相互独立的，容易扩展
    • 由于具体的建造者模式是独立的，因此可以对建造过程逐步细化，而不对其他模块产生影响

 

• • 缺点：
    • 产生多余的Builder对象以及导演类