设计模式(5)-建造者模式详解(易懂)

建造者模式定义

定义：建造者模式是设计模式的一种，将一个复杂对象的构建与它的表示分离，使得一样的构建过程能够建立不一样的表示。

先分析模型图上的四大部分：

• Product：产品类，指要建立的复杂对象，一般实现了模板方法模式。
• Builder：抽象建造类，规范产品的组建，通常是由子类实现的。
• ConcreteBuilder：具体建造类，实现抽象建造类定义的方法并返回一个建造好的对象。
• Director：导演类，也就是指挥者，负责安排流程。

实例说明

就拿建造房屋举例吧：这里假设建造两种类型的房屋，别墅和普通房屋；两种类型的建造流程顺序不一样；别墅为A-B-C三步，普通房屋为C-B-A三步。

1.首先定义出Product类，VillaModel和OrdinaryhouseModel

(1).抽象产品类

public abstract class HouseModel  {
   //定义执行的顺序，放在集合内
   private List<String> OrderList=new ArrayList<>();

   //建造房屋的步骤，不分前后，不一样的房屋，顺序不一样
   protected  abstract  void buildstepA();
   protected  abstract  void buildstepB();
   protected  abstract  void buildstepC();
  /*
  建造房屋
   */
   final  public void build(){
       for (int i=0;i<this.OrderList.size();i++){
           String name =this.OrderList.get(i);
           if (name.equalsIgnoreCase("stepA")){
               this.buildstepA();
           }else if (name.equalsIgnoreCase("stepB")){
               this.buildstepB();
           }else if (name.equalsIgnoreCase("stepC")){
               this.buildstepC();
           }
       }

   }
   //设置顺序
   public void setOrderList(List<String> orderList) {
       OrderList = orderList;
   }
}

(2).两个实现类

public class VillaModel extends HouseModel {
   @Override
   protected void buildstepA() {
    System.out.println("别墅建造步骤A操做");   
   }

   @Override
   protected void buildstepB() {
       System.out.println("别墅建造步骤B操做");
   }

   @Override
   protected void buildstepC() {
       System.out.println("别墅建造步骤C操做");
   }
}

public class OrdinaryhouseModel extends HouseModel {
   @Override
   protected void buildstepA() {
       System.out.println("普通房屋建造步骤A操做");
   }

   @Override
   protected void buildstepB() {
       System.out.println("普通房屋建造步骤B操做");
   }

   @Override
   protected void buildstepC() {
       System.out.println("普通房屋建造步骤C操做");
   }
}

2.定义Builder抽象建造类，也就是写两种房屋的建造方式.

public abstract class HouseBuilder  {
   //为了设置建造顺序
   public  abstract  void  setOrderList(List<String> orderList);

   //获取安排完建造顺序的对应的房屋
   public  abstract  HouseModel getHouseModel();
}

3.定义ConcreteBuilder具体建造类，也就是两种房屋建造类实现上面定义的Builder

//别墅
public class VillaBuilder extends HouseBuilder {
   private  VillaModel villaModel=new VillaModel();
   @Override
   public void setOrderList(List<String> orderList) {
       this.villaModel.setOrderList(orderList);
   }

   @Override
   public HouseModel getHouseModel() {
       return this.villaModel;
   }
}

//普通房屋
public class OrdinaryhouseBuilder extends HouseBuilder {
   private  OrdinaryhouseModel ordinaryhouseModel=new OrdinaryhouseModel();
   @Override
   public void setOrderList(List<String> orderList) {
       this.ordinaryhouseModel.setOrderList(orderList);
   }

   @Override
   public HouseModel getHouseModel() {
       return this.ordinaryhouseModel;
   }
}

注意：上面的准备工做都作完了，为了更深入的理解Director<导演类>，咱们先不加Director，直接去实现此实例。

不加入Director类，实现方式就是直接设置顺序，以建造别墅为例，代码以下：

List<String> OrderList=new ArrayList<>();
       OrderList.add("stepA");
       OrderList.add("stepB");
       OrderList.add("stepC");

       VillaBuilder villaBuilder=new VillaBuilder();
       villaBuilder.setOrderList(OrderList);

       VillaModel villaModel= (VillaModel) villaBuilder.getHouseModel();
       villaModel.build();

这还只是别墅的建造，代码是否是很臃肿？因此封装是必须的，既加上Director类来指挥(封装)顺序。

4.定义Director类，也就是对已知的两种房屋的建造步骤进行封装

public class Director {
   private List<String> OrderList=new ArrayList<>();
   private  OrdinaryhouseBuilder ordinaryhouseBuilder=new OrdinaryhouseBuilder();
   private  VillaBuilder villaBuilder=new VillaBuilder();
/*
普通房屋建造步骤封装
*/
   public OrdinaryhouseModel getHouseModel(){
       this.OrderList.clear();
       this.OrderList.add("stepC");
       this.OrderList.add("stepB");
       this.OrderList.add("stepA");
       this.ordinaryhouseBuilder.setOrderList(OrderList);
       return (OrdinaryhouseModel) this.ordinaryhouseBuilder.getHouseModel();
   }
   /*
   别墅建造步骤封装
    */
   public VillaModel getvillaModel(){
       this.OrderList.clear();
       this.OrderList.add("stepA");
       this.OrderList.add("stepB");
       this.OrderList.add("stepC");
       this.villaBuilder.setOrderList(OrderList);
       return (VillaModel) this.villaBuilder.getHouseModel();
   }

}

这时实现实例的代码以下：

Director director=new Director();
       director.getHouseModel().build();
       director.getvillaModel().build();

运行结果：

加入了Director类后调用是否是感受很简单，清晰了。另外若是两种房屋的建造步骤有变化了，能够直接在Director类封装新的顺序。

建造者模式应用

1.实用范围

• 当建立复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
• 当构造过程必须容许被构造的对象有不一样表示时。

2.建造者模式的优缺点

(1).优势

• 封装性好
• 具体建造类之间独立，扩展性好

(2).缺点

产生多余的Build对象以及Dirextor类。

3.建造者模式与工厂模式的区别

这两种模式很类似，建造者模式更注重于方法的调用顺序，而工厂模式注重于建立产品。具体的区别仍是推荐你们去亲身去了解一下这两种模式。

文章学习参考了《设计模式之禅》《Android进阶之光》

---

另外能够加入个人Android技术交流群：458739310
你们能够关注个人微信公众号：「安卓干货铺」一个有质量、有态度的公众号！