每天一个设计模式之(4)-----建造者模式-CSDN博客

1.为什么要使用建造者模式

建造者模式的定义是：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。我们常常会在一些框架的使用中有这样的用法：

Builder.setXXX().setYYY().setZZZ().build();

这种用法其实就是使用了建造者模式，它使得前面的几个方法是构建，最后一个步骤是生成。

2.先上一波类图

接上一篇模板方法的例子，现在多了一个需求，有的车的run()是先按喇叭再启动，有的车是先启动再按喇叭，那么我们就在抽象车里面增加一个表示顺序的ArrayList，调用run（）的时候，根据ArrayList去遍历顺序。

核心的就是中间的CarBuilder了，setSequence()就是表示对象的构建过程，buildCar()就是对象的构建了。Derictor，调用了CarBuilder，并封装了两个造车的方法（这一步并不属于建造者模式）

3.建造者模式的实现

Car相关的类

public abstract class AbstractCar {

    private ArrayList sequence;//顺序

    //启动
    protected abstract void start();
    //喇叭
    protected abstract void alarm();
    //熄火
    protected abstract void stop();

    public final void run(){
        // 根据 ArrayList 进行遍历，表示顺序
        for (int i = 0; i < this.sequence.size(); i++) {

            if("start".equals(this.sequence.get(i))){
                this.start();
            }
            if("alarm".equals(this.sequence.get(i))){
                this.alarm();
            }
            if("stop".equals(this.sequence.get(i))){
                this.stop();
            }
        }
    }

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

public class BenZ extends AbstractCar{

    @Override
    public void start() {
        System.out.println("BenZ start");
    }

    @Override
    public void alarm() {
        System.out.println("BenZ alarm");
    }

    @Override
    public void stop() {
        System.out.println("BenZ stop");
    }
}

public class BMW extends AbstractCar{

    @Override
    public void start() {
        System.out.println("BMW start");
    }

    @Override
    public void alarm() {
        System.out.println("BMW alarm");
    }

    @Override
    public void stop() {
        System.out.println("BMW stop");
    }
}

建造者相关的类

public abstract class CarBuilder {

    //设置顺序
    public abstract void setSequence(ArrayList<String> sequence);

    //建造车
    public abstract AbstractCar buildCar();
}


public class BenZBuilder extends CarBuilder{

    private BenZ benZ = new BenZ();

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

    @Override
    public AbstractCar buildCar() {
        return this.benZ;
    }
}

public class BMWBuilder extends CarBuilder{

    private BMW bmw = new BMW();

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

    @Override
    public AbstractCar buildCar() {
        return this.bmw;
    }
}

导演类

/**
 * 封装一层
 */
public class Derictor {

    private ArrayList sequence = new ArrayList();
    private CarBuilder carBuilder;

    public BenZ getBenZ(){
        sequence.clear();
        this.sequence.add("start");
        this.sequence.add("alarm");
        this.sequence.add("stop");
        carBuilder = new BenZBuilder();
        carBuilder.setSequence(this.sequence);
        return (BenZ) carBuilder.buildCar();
    }

    public BMW getBMW(){
        sequence.clear();
        this.sequence.add("alarm");
        this.sequence.add("start");
        this.sequence.add("stop");
        carBuilder = new BMWBuilder();
        carBuilder.setSequence(this.sequence);
        return (BMW) carBuilder.buildCar();
    }
}

main方法

public class Main {

    public static void main(String[] args) {
        //先把创造者创建出来
        CarBuilder builder = new BenZBuilder();

        //自定义顺序
        ArrayList<String> sequence = new ArrayList<String>();
        sequence.add("alarm");
        sequence.add("start");
        sequence.add("stop");
        builder.setSequence(sequence);

        //开始建造汽车，按照自定义的顺序
        AbstractCar car = builder.buildCar();
        car.run();

        //完整的建造者模式，封装后的操作，其实和上面没什么差别，
        //只是一种车的顺序是固定的，所以就加一层封装
        Derictor derictor = new Derictor();
        derictor.getBenZ().run();
        derictor.getBMW().run();
    }

}

转载于:https://my.oschina.net/u/3582320/blog/1162395