DesignPattern_建造者模式_05

建造者模式

学习自 《设计模式之禅(第二版)》

定义

Separate the construction of a complex objectfrom its representation so that the sameconstruction process can create differentrepresentations.
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
角色：

• Product产品类
  通常是实现了模板方法模式，也就是有模板方法和基本方法。例子中 BMWModel 和BenzModel属于产品类
• Builder抽象建造者
  规范产品的组建，一般是由子类实现。例子中CarBuilder就属于抽象建造者。
• ConcreteBuilder具体建造者
  实现抽象类定义的所有方法，并且返回一个组建好的对象。例子中BenzBuilder和BMWBuilder就属于具体构建者
• Director导演类
  负责安排已有模块的顺序，然后告诉Builder开始构建

建造者模式的优点

• 封装性
  使用建造者模式可以使客户端不必知道产品内部组成的细节，如例子中我们就不需要关心每一个具体的模型内部是如何实现的，产生的对象类型就是CarModel。
• 建造者独立，容易扩展
  BenzBuilder和BMWBuilder是相互独立的，对系统的扩展非常有利。
• 便于控制细节风险
  由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。

建造者模式使用场景

相同的方法，不同的执行顺序，产生不同的事件结果时，可以采用建造者模式。多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时，则可以使用该模式。产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式非常合适。在对象创建过程中会使用到系统中的一些其他对象，这些对象在产品对象的创建过程中不易得到时，也可以采用建造者模式封装该对象的创建过程。该种场景只能是一个补偿方法，因为一个对象不容易获得，而在设计阶段竟然没有发觉，而要通过创建者模式柔化创建过程，本身已经违反设计的最初目标。

建造者模式最主要的功能是基本方法的调用顺序安排，也就是这些基本方法已经实现了，通俗地说就是零件的装配，顺序不同产生的对象也不同。工厂模式注重的是创建，创建零件是主要职责，组装顺序则不是工厂模式关心的。

代码实现

package design;

import java.util.ArrayList;
import java.util.List;

/**
 * @author huangqh
 * @create 2020/12/8 11:08
 * @Notes 建造者模式
 */
public class Builder {
}

/**
 * 车辆模型抽象类
 */
abstract class CarModel {
    private List<String> sequence = new ArrayList<>();

    protected abstract void start();

    protected abstract void stop();

    protected abstract void alarm();

    protected abstract void engineBoom();

    final public void run() {
        for (int i = 0; i < sequence.size(); i++) {
            String actionName = this.sequence.get(i);
            if (actionName.equalsIgnoreCase("start"))
                this.start();
            else if (actionName.equalsIgnoreCase("stop"))
                this.stop();
            else if (actionName.equalsIgnoreCase("alarm"))
                this.alarm();
            else if (actionName.equalsIgnoreCase("engineBoom"))
                this.engineBoom();
        }
    }

    final public void setSequence(ArrayList sequence) {
        this.sequence = sequence;
    }
}

/**
 * Benz模型
 */
class BenzModel extends CarModel {

    @Override
    protected void start() {
        System.out.println("Benz应该这样启动");
    }

    @Override
    protected void stop() {
        System.out.println("Benz应该这样停车");
    }

    @Override
    protected void alarm() {
        System.out.println("Benz的喇叭是这样的");
    }

    @Override
    protected void engineBoom() {
        System.out.println("Benz的喇叭声音是这样的");
    }
}

class BMWModel extends CarModel {

    @Override
    protected void start() {
        System.out.println("BMW是这样启动的");
    }

    @Override
    protected void stop() {
        System.out.println("BMW是这样停车的");
    }

    @Override
    protected void alarm() {
        System.out.println("BMW喇叭声音是这样的");
    }

    @Override
    protected void engineBoom() {
        System.out.println("BMW引擎是这个声音");
    }
}

/**
 * 非建造者模式客户端
 */
class Client {
    public static void main(String[] args) {
        BenzModel benz = new BenzModel();
        ArrayList<String> sequence = new ArrayList<>();
        sequence.add("engineBoom");
        sequence.add("start");
        sequence.add("stop");
        benz.setSequence(sequence);
        benz.run();
    }
}
/**
 * 下面是建造着模式相关代码
 */

/**
 * 抽象汽车组装者
 */
abstract class CarBuilder {
    /**
     * 建造一个模型，需要一个顺序要求
     *
     * @param sequence
     */
    public abstract void setSequence(ArrayList<String> sequence);

    /**
     * 设置顺序后，可以直接拿到这个车辆模型
     *
     * @return
     */
    public abstract CarModel getCarModel();
}

/**
 * Benz组装者
 */
class BenzBuilder extends CarBuilder {

    private BenzModel benz = new BenzModel();

    @Override
    public void setSequence(ArrayList<String> sequence) {
        this.benz.setSequence(sequence);
    }

    @Override
    public CarModel getCarModel() {
        return this.benz;
    }
}

/**
 * BMW组装者
 */
class BMWBuilder extends CarBuilder {
    private BMWModel bwm = new BMWModel();

    @Override
    public void setSequence(ArrayList<String> sequence) {
        this.bwm.setSequence(sequence);
    }

    @Override
    public CarModel getCarModel() {
        return this.bwm;
    }
}

/**
 * Director导演类
 */
class Director {
    private ArrayList<String> sequence = new ArrayList<>();
    private BenzBuilder benzBuilder = new BenzBuilder();
    private BMWBuilder bmwBuilder = new BMWBuilder();

    /**
     * 获取A型号Benz————只有启动和停止功能
     *
     * @return
     */
    public BenzModel getBenzModel_A() {
        this.sequence.clear();
        this.sequence.add("start");
        this.sequence.add("stop");
        this.benzBuilder.setSequence(this.sequence);
        return (BenzModel) this.benzBuilder.getCarModel();
    }

    /**
     * 获取B型号Benz————只有喇叭
     */
    public BenzModel getBenzModel_B() {
        this.sequence.clear();
        this.sequence.add("alarm");
        this.benzBuilder.setSequence(this.sequence);
        return (BenzModel) this.benzBuilder.getCarModel();
    }

    /**
     * 获取C型号BMW————只有启动
     */
    public BMWModel getBMWModel_C() {
        this.sequence.clear();
        this.sequence.add("start");
        this.bmwBuilder.setSequence(this.sequence);
        return (BMWModel) this.bmwBuilder.getCarModel();
    }
}

/**
 * 建造者模式客户端
 */
class BuilderClient {
    public static void main(String[] args) {
        Director director = new Director();
        director.getBenzModel_A().run();
        director.getBenzModel_B().run();
        director.getBMWModel_C().run();
    }
}