建造者模式

定义

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

代码

比如现在要造不同的车子，车子的动作顺序可以自己定义，从而生成不同的车子

首先定义车子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public abstract class Car {
    private List<String> sequence = new ArrayList<>();
    public abstract void start();
    public abstract void stop();
    public abstract void alarm();
    final public void run(){
        for (String action : sequence) {
            if(action.equalsIgnoreCase("start")){
                this.start();
            }else if(action.equalsIgnoreCase("stop")){
                this.stop();
            }else if(action.equalsIgnoreCase("alarm")){
                this.alarm();
            }
        }
    }
    final public void setSequence(List<String> sequence) {
        this.sequence = sequence;
    }
}

上面定义了一个车子的模板，使用sequence来控制车子的动作顺序，下面定义实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class CarA extends Car {

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

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

    @Override
    public void alarm() {
        System.out.println("car A alarm");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class CarB extends Car {
    @Override
    public void start() {
        System.out.println("car B start");
    }

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

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

现在车子有了，既然要造车子，现在定义建造者

1
2
3
4
5
6
public abstract class CarBuilder {
    //执行顺序
    public abstract void setSequence(List<String> sequence);
    //返回对象
    public abstract Car getCar();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
public class CarABuilder extends CarBuilder {
    private Car carA = new CarA();

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

    @Override
    public Car getCar() {
        return this.carA;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
public class CarBBuilder extends CarBuilder {
    private Car carB = new CarB();
    @Override
    public void setSequence(List<String> sequence) {
        this.carB.setSequence(sequence);
    }

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

上面首先定义了建造者，需要传入顺序，然后返回对应的车子，现在只需要一个导演类来实现具体车子的顺序制造

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class Director {
    private List<String> sequence = new ArrayList<>();
    private CarBuilder aBuilder = new CarABuilder();
    private CarBuilder bBuilder = new CarBBuilder();

    public Car getCarA(){
        this.sequence.clear();
        this.sequence.add("stop");
        this.sequence.add("alarm");
        this.sequence.add("start");
        this.aBuilder.setSequence(this.sequence);
        return this.aBuilder.getCar();
    }

    public Car getCarB(){
        this.sequence.clear();
        this.sequence.add("alarm");
        this.sequence.add("stop");
        this.sequence.add("start");
        this.bBuilder.setSequence(this.sequence);
        return this.bBuilder.getCar();
    }
    //...其他类型(顺序)的CarA   CarB

}

测试：

1
2
3
4
5
6
7
public void testBuilder(){

       Director director = new Director();
       director.getCarA().run();
       director.getCarB().run();

   }