设计模式学习（七）建造者模式

介绍

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

类图说明

该类图还是沿用咱们之前的车的场景来做说明，从图中可以看出，建造者模式很像是抽象模式的拓展。
首先我们先创建了一个抽象方法，抽象方法里包含了start,stop,run抽象方法，需要子类去继承实现，然后定义了一个抽象方法driver()，该方法依赖sequence()的集合来判断是否调用start,stop,run几个方法。
到此建造者登场，简单来说建造者就是对我们sequence()集合设置值，来改变咱们Car抽象方法的执行结果，当然建造者可以有无数种可能，比如是否同时生产两种类型车等，都可以定义。最后面我们Director来指挥组合建造者构建最终的产品给到客户，也就是我们最后面的BuilderPattern进行具体的调用

代码示例

文件结构如下：

代码示例如下：

public abstract class Car {
    
    

    private List<String> sequence = new ArrayList<>();

    public abstract void start();
    public abstract void run();
    public abstract void stop();

    // 模板类具体实现
    public void drive(){
    
    
        sequence.stream().forEach(str -> {
    
    
            if("start".equals(str)){
    
    
                start();
            }
            if("run".equals(str)){
    
    
                run();
            }
            if("stop".equals(str)){
    
    
                stop();
            }
        });
    }

    public void setSequence(List<String> sequence){
    
    
        this.sequence = sequence;
    }
}

public class Benz extends Car {
    
    
    @Override
    public void start() {
    
    
        System.out.println("奔驰车启动中");
    }

    @Override
    public void run() {
    
    
        System.out.println("奔驰车行使中");
    }

    @Override
    public void stop() {
    
    
        System.out.println("奔驰车停止中");
    }
}

public class BMW extends Car {
    
    
    @Override
    public void start() {
    
    
        System.out.println("宝马车启动中");
    }

    @Override
    public void run() {
    
    
        System.out.println("宝马车行使中");
    }

    @Override
    public void stop() {
    
    
        System.out.println("宝马车停止中");
    }
}

public abstract class CarBuilder {
    
    
    public abstract Car getCar();
    public abstract void setSequence(List<String> sequence);
}

public class BMWBuilder extends CarBuilder {
    
    

    BMW bmw = new BMW();

    @Override
    public Car getCar() {
    
    
        return this.bmw;
    }

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

public class BenzBuilder extends CarBuilder {
    
    

    Benz benz = new Benz();

    @Override
    public Car getCar() {
    
    
        return this.benz;
    }

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

public class Director {
    
    

    public Benz getABenz(){
    
    
        BenzBuilder benzBuilder = new BenzBuilder();
        List<String> sequence = new ArrayList<>();
        sequence.add("start");
        sequence.add("run");
        sequence.add("stop");
        benzBuilder.setSequence(sequence);
        return (Benz) benzBuilder.getCar();
    }

    public Benz getBBenz(){
    
    
        BenzBuilder benzBuilder = new BenzBuilder();
        List<String> sequence = new ArrayList<>();
        sequence.add("start");
        sequence.add("stop");
        benzBuilder.setSequence(sequence);
        return (Benz) benzBuilder.getCar();
    }

    public BMW getABMW(){
    
    
        BMWBuilder bmwBuilder = new BMWBuilder();
        List<String> sequence = new ArrayList<>();
        sequence.add("start");
        sequence.add("run");
        sequence.add("stop");
        bmwBuilder.setSequence(sequence);
        return (BMW) bmwBuilder.getCar();
    }
}

public class BuilderPattern {
    
    
    public static void main(String[] args){
    
    
        Director director = new Director();
        System.out.println("奔驰A款车自动驾驶测试中：");
        director.getABenz().drive();
        System.out.println("奔驰B款车自动驾驶测试中：");
        director.getBBenz().drive();
        System.out.println("宝马A款车自动驾驶测试中：");
        director.getABMW().drive();
    }
}

运行结果如下：

应用场景

• 需要生成的对象具有复杂的内部结构
• 需要生成的对象内部属性本身相互依赖

优缺点

优点

• 建造者独立，易扩展
• 便于控制细节风险

缺点

• 产品必须有共同点，范围有限制
• 如内部变化复杂，会有很多的建造类

注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。