设计模式-构建者模式_构造者模式好处

概要： 创建者模式又叫建造者模式，是将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。创建者模式隐藏了复杂对象的创建过程，它把复杂对象的创建过程加以抽象，通过子类继承或者重载的方式，动态的创建具有复合属性的对象。

构造者模式的优点

①使用建造者模式可以使客户端不必知道产品内部组成的细节。

②具体的建造者类之间是相互独立的，这有利于系统的扩展。

③具体的建造者相互独立，因此可以对建造的过程逐步细化，而不会对其他模块产生任何影响。

代码示例

描述： 加入我们现在要制造一辆汽车，需要很复杂的过程，我们现在将这些过程抽取出来，构建者 创建一个汽车对象。

• 要构造的很复杂的对象（Car对象）

public class Car {
    private String name;
    private String color;
    private String weight;
    private String price;
    private String fadongji;
    private String luntai;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getWeight() {
        return weight;
    }

    public void setWeight(String weight) {
        this.weight = weight;
    }

    public String getPrice() {
        return price;
    }

    public void setPrice(String price) {
        this.price = price;
    }

    public void setFadongji(String fadongqi) {
        this.fadongji = fadongqi;
    }

    public String getFadongji() {
        return fadongji;
    }

    public void setLunTai(String luntai) {
        this.luntai = luntai;
    }

    public String getLuntai() {
        return luntai;
    }

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                ", weight='" + weight + '\'' +
                ", price='" + price + '\'' +
                ", fadongji='" + fadongji + '\'' +
                ", luntai='" + luntai + '\'' +
                '}';
    }
}

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

• 对该对象进行抽取

public interface ICarBuilder {

    void setName(String name);
    void setColor(String color);
    void setPrice(String price);
    void setFadongji(String fadongji);
    void setLuntai(String luntai);
    void setWeight(String weight);

    Car builderCar();
}

1
2
3
4
5
6
7
8
9
10
11
12

• 创建构建者并继承 抽取的 构造逻辑

public class Builder implements ICarBuilder {
    private Car car;

    public Builder() {
        this.car = new Car();
    }

    @Override
    public void setName(String name) {
        car.setName(name);
    }

    @Override
    public void setColor(String color) {
        car.setColor(color);
    }

    @Override
    public void setPrice(String price) {
        car.setPrice(price);
    }

    @Override
    public void setFadongji(String fadongji) {
        car.setFadongji(fadongji);
    }

    @Override
    public void setLuntai(String luntai) {
        car.setLunTai(luntai);
    }

    @Override
    public void setWeight(String weight) {
        car.setWeight(weight);
    }

    @Override
    public Car builderCar() {
        return car;
    }
}

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

• 指导者，负责调用构造对象的逻辑（控制相应的构造顺序）

public class Director {
    public Car constractorCar(ICarBuilder iCarBuilder){

        iCarBuilder.setName("奔驰");
        iCarBuilder.setColor("红色");
        iCarBuilder.setFadongji("te4s发动机");
        iCarBuilder.setLuntai("bai轮胎");
        iCarBuilder.setPrice("1000");
        iCarBuilder.setWeight("40KG");

        Car car = iCarBuilder.builderCar();
        return car;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• 测试demo

public class Test {

    public static void main(String[] args) {
        ICarBuilder iCarBuilder = new Builder();
        Director director = new Director();
        Car car = director.constractorCar(iCarBuilder);

        System.out.println(car);
    }
}
1
2
3
4
5
6
7
8
9
10