设计模式---建造者模式

定义

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

 

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

 

案例

/**
 * 汽车模型类（抽象类）
 */
public abstract class CarModel {
    //汽车组装顺序
    private List<String> sequence = new ArrayList<String>();
    //汽车启动
    protected abstract void start();
    //汽车停止
    protected abstract void stop();
    //汽车响喇叭
    protected abstract void alarm();
    //汽车引擎声
    protected abstract void engineBoom();
    //开车
    public final void run() {
        for (String s : sequence) {
            if ("start".equalsIgnoreCase(s)) {
                this.start();
            } else if ("stop".equalsIgnoreCase(s)) {
                this.stop();
            } else if ("alarm".equalsIgnoreCase(s)) {
                this.alarm();
            } else if ("engineBoom".equalsIgnoreCase(s)) {
                this.engineBoom();
            }
        }
    }

    //设置汽车组装顺序
    protected final void setSequence(List<String> sequence) {
        this.sequence = sequence;
    }

}

 

/**
 * 奔驰车模型
 */
public class BenzModel extends CarModel {
    @Override
    protected void start() {
        System.out.println("奔驰车---启动...");
    }

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

    @Override
    protected void alarm() {
        System.out.println("奔驰车---响喇叭...");
    }

    @Override
    protected void engineBoom() {
        System.out.println("奔驰车---引擎声...");
    }
}

 

/**
 * 宝马车模型
 */
public class BMWModel extends CarModel {
    @Override
    protected void start() {
        System.out.println("宝马车---启动...");
    }

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

    @Override
    protected void alarm() {
        System.out.println("宝马车---响喇叭...");
    }

    @Override
    protected void engineBoom() {
        System.out.println("宝马车---引擎声...");
    }
}

 

/**
 * 抽象汽车组装者
 */
public abstract class CarBuilder {
    //设置汽车组装顺序
    protected abstract void setSequence(List<String> sequence);
    //获取汽车模型
    protected abstract CarModel getCarModel();

}

 

/**
 * 奔驰车组装者
 */
public class BenzBuilder extends CarBuilder {

    private BenzModel benz = new BenzModel();

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

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

 

/**
 * 宝马车组装者
 */
public class BMWBuilder extends CarBuilder {

    private BMWModel bmw = new BMWModel();

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

    @Override
    protected CarModel getCarModel() {
        return this.bmw;
    }
}

 

/**
 * 导演类
 */
public class Director {

    private List<String> sequence = new ArrayList<String>();
    private BenzBuilder benzBuilder = new BenzBuilder();
    private BMWBuilder bmwBuilder = new BMWBuilder();

    //建造奔驰车模型
    public BenzModel getBenzModel() {
        this.sequence.clear();
        this.sequence.add("start");
        this.sequence.add("stop");
        this.benzBuilder.setSequence(this.sequence);
        return (BenzModel) this.benzBuilder.getCarModel();
    }

    //建造宝马车模型
    public BMWModel getBMWModel() {
        this.sequence.clear();
        this.sequence.add("start");
        this.sequence.add("alarm");
        this.sequence.add("stop");
        this.bmwBuilder.setSequence(this.sequence);
        return (BMWModel) this.bmwBuilder.getCarModel();
    }
    
}

 

public class BuilderPatternDemo {

    public static void main(String[] args) {
        Director director = new Director();
        BenzModel benzModel = director.getBenzModel();
        benzModel.run();
        BMWModel bmwModel = director.getBMWModel();
        bmwModel.run();
    }

}

建造这模式对创建对象的复杂过程进行封装，用户只需要调用方法来获取对象，而不用考虑它的创建，大大提高了代码的复用性和封装性。