设计模式建造者模式(图解,使用场景)

设计模式-建造者模式

建造者模式,本文讲了注意事项,使用环境,定义等多种情况.

1. 定义

　　将一个复杂对象的构建与它的表示相分离,使得同样的构建过程可以创建不同的表示;

　　其中有四种角色

　　　　Product 产品

　　　　　　通常是实现了模板方法模式,也就是有模板方法和基本方法,

　　　　Builder 抽象建造者

　　　　　　规范产品的重组,一般由子类完成

　　　　ConcreteBuilder具体建造者

　　　　　　实现抽象类定义的所有方法,并且返回一个好的对象.

　　　　Director 导演类

　　　　　　负责安排已有模块的顺序,然后开始告诉builder 建造

　　1.2 建造类的基本代码

　　　　1.2.1 product 产品

　　　　　　

public class Product(){
    
   public void doSomething(){
       //具体什么事情
    }
}

　　　　1.2.2 抽象建造类

　

public abstract class Builder {
    //设置不同产品的不同部分
     public abstract void setPart();
    //建造产品
    public abstract Product buildProduct();
    }

　　1.2.3 具体建造者

　　

public class ConcreateProduct extends Buidlder{
   private Product pro = new Product();
      
   //设置产品步骤,细节
     public void setPart(){
     //产品类的逻辑处理
  }  
   
   //组建一个产品
   public Product builidProduct(){
       return product;    
  }  
}

　　1.2.4 导演类

　　起到封装的作用,避免高层模块深入到建造者内部的实现类中.当然如果建造类模式比较庞大时,导演类可以有多个.

public class Director{
  private Builder builder = new ConcreateBuilder();
    
  //构建不同的产品
  public Product getProductA(){
     builder.setPart();
    return builder.builidProduct();    
  }
}

2 . 具体例子

这里其实我们也使用了 "模板方法"模式的,有兴趣的朋友可以看下我上个 ::设计模式-模板方法模式的实现的

2.1 产品类

　　

public abstract class CarModel {
    //各方法执行的顺序
    private ArrayList<String>seqList = new ArrayList<>();
    //启动
    protected abstract void start();
    //鸣笛
    protected abstract void didi() ;
    //跑起来
    protected abstract void run();
    //停止
    protected abstract void stop();
    
    //模板方法
    final public void exc(){
        //循环判断执行顺序
        for (String seq : seqList) {
            if (seq.equalsIgnoreCase("start")) {
                start();
            }else if (seq.equalsIgnoreCase("didi")) {
                didi();
            }else if (seq.equalsIgnoreCase("run")) {
                run();
            }else if (seq.equalsIgnoreCase("stop")) {
                stop();
            }
        }
    }
    
    //设置seqList值
    public final void setSeqList(ArrayList<String> seqList){
        this.seqList = seqList;
    }
}

//具体产品实现类
public class BenzModel extends CarModel {

    // 启动
    protected void start() {
        System.out.println("奔驰启动");
    }

    // 鸣笛
    protected void didi() {
        System.out.println("奔驰鸣笛");
    }

    // 跑起来
    protected void run() {
        System.out.println("奔驰跑起来");
    }

    // 停止
    protected void stop() {
        System.out.println("奔驰停下来");
    }
}

//测试类

public class Test {
    public static void main(String[] args) {
        BenzModel benz = new BenzModel();
        ArrayList<String>list = new ArrayList<>();
        list.add("start");
        list.add("didi");
        list.add("stop");
        benz.setSeqList(list);
        benz.exc();
    }
}

以上主要是模板设计模式的使用.现在根据需求改装

// 1. 抽象汽车组装者

public abstract class CarBuilder {
    //建造一个模型
    public abstract void setSeqList(ArrayList<String> seqList);
    //模型完成后,就可以直接拿到这个模型
    public abstract CarModel getCarModel();
}

/2 .具体的组装者

public class BenzBuilder extends CarBuilder{

    private BenzModel benzModel = new BenzModel();
    public void setSeqList(ArrayList<String> seqList) {
        this.benzModel.setSeqList(seqList);
    }

    public CarModel getCarModel() {
        return this.benzModel;
    }

}

3.要一个奔驰车

public class Cilent {
    public static void main(String[] args) {
        /**
         * 设置一个顺序List
         */
        ArrayList<String>seqList = new ArrayList<>();
        seqList.add("start");
        seqList.add("didi");
        seqList.add("stop");
        //要一个奔驰车
        BenzBuilder benzBuilder = new BenzBuilder();
        benzBuilder.setSeqList(seqList);
        BenzModel benzModel = (BenzModel) benzBuilder.getCarModel();
        benzModel.exc();
    }
}

4.导演类

public class Director {
    ArrayList<String> seqList = new ArrayList<>();
    // 这里可以有多个,具体的创建类
    BenzBuilder benzBuilder = new BenzBuilder();

    // A种奔驰
    public BenzModel getABenz() {
        seqList.clear();
        seqList.add("start");
        seqList.add("end");
        benzBuilder.setSeqList(seqList);
        return (BenzModel) benzBuilder.getCarModel();
    }

    // B种奔驰
    public BenzModel getBBenz() {
        seqList.clear();
        seqList.add("start");
        seqList.add("didi");
        seqList.add("end");
        benzBuilder.setSeqList(seqList);
        return (BenzModel) benzBuilder.getCarModel();
    }
}

这样确定了完成细节,就能呢个直接获得某种产品了.

 

3.建造者的应用 

 3.1 建造者的优点

　　1.封装性,全部都封装得特别好

　　2.独立性,扩展性,需要扩展了就直接添加一个品种就行

　　3.便于控制细节风险控制

3.2 使用场景

　　1.相同的的方法,不同的执行顺序,产生不同的结果

　　2.多个部件和零件,都可以装配到一个对象中去,但是产生的结果又不相同

　　3.产品类特别复杂,或者产品类中的调用顺序 不同产生了不同的效能,

　　4.在建造者模式中使用到系统的一些其他对象,这些对象在创建过程中不易得到时,也可以采用才模式封装创建过程.这样只是一个补偿方法.

3.3 和工厂模式的不同

　　看着很像,但是确非常不同,这个我们在后面的工厂模式中再细细讲解吧

3.4  使用的时候一定要注意 "模板设计"模式,两个搭配起来用,这个是非常重要的