《大话设计模式》——读后感 （8）好菜每回味不同——建造者模式之基础案例（1）

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

建造者模式通常包括下面几个角色：

1. builder：给出一个抽象接口，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建，并不涉及具体的对象部件的创建。

2. ConcreteBuilder：实现Builder接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。 在建造过程完成后，提供产品的实例。

3. Director：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。

4. Product：要创建的复杂对象

UML类图：

重要：建造者模式，是要有最终的建造对象，即Product。这一点与外观模式有最明显的区别。

具体产品（建造对象）：

package com.sjmx.builder;

public class Entity {

    protected String name;
    protected String age;
    protected String sex;
    protected String height;
    protected String weight;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getHeight() {
        return height;
    }
    public void setHeight(String height) {
        this.height = height;
    }
    public String getWeight() {
        return weight;
    }
    public void setWeight(String weight) {
        this.weight = weight;
    }

    @Override
    public String toString() {

        return "名字:" + this.name +",性别:" + this.sex + ",身高：" + this.height
                + ",体重:" + this.weight + ",年龄：" +  this.age;
    }
}

抽象接口：

package com.sjmx.builder;

public interface Builder {

    void buildName();
    void buildAge();
    void buildSex();
    void buildHeight();
    void buildWeight();

}

具体建造者1：

package com.sjmx.builder;

public class ConBuilder1 implements Builder {

    Entity entity = new Entity();

    @Override
    public void buildName() {
        entity.setName("cook");
    }

    @Override
    public void buildAge() {
         entity.setAge("10");
    }

    @Override
    public void buildSex() {
         entity.setSex("boy");
    }

    @Override
    public void buildHeight() {
        entity.setHeight("165cm");
    }

    @Override
    public void buildWeight() {
        entity.setWeight("54kg");
    }

    public Entity getResult(){
        return entity;
    }
}

具体建造者2（也可以仅有一个建造者）：

package com.sjmx.builder;

public class ConBuilder2 implements Builder {

    Entity entity = new Entity();

    @Override
    public void buildName() {
        entity.setName("jack");
    }

    @Override
    public void buildAge() {
         entity.setAge("10");
    }

    @Override
    public void buildSex() {
         entity.setSex("girl");
    }

    @Override
    public void buildHeight() {
        entity.setHeight("175cm");
    }

    @Override
    public void buildWeight() {
        entity.setWeight("54kg");
    }

    public Entity getResult(){
        return entity;
    }

}

指挥者（此处我使用静态方法实现，方便客户端直接调用；实战中可以不使用静态方法）：

package com.sjmx.builder;

public class Director {

     static void build(Builder b){
         b.buildHeight();
         b.buildWeight();
         b.buildSex();
         b.buildAge();
         b.buildName();
    }

}

客户端：

package com.sjmx.builder;

public class Client {

    public static void main(String[] args) {

        ConBuilder1 c1 = new ConBuilder1();
        ConBuilder2 c2 = new ConBuilder2();

        Director.build(c1);
        Director.build(c2);

        Entity t1 =    c1.getResult();
        Entity t2 =    c2.getResult();

        System.out.println(t1.toString());
        System.out.println(t2.toString());
    }
}

运行结果：

使用建造者模式的好处：

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

2.具体的建造者类之间是相互独立的，对系统的扩展非常有利。

3.由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。

使用建造模式的场合：

1.创建一些复杂的对象时，这些对象的内部组成构件间的建造顺序是稳定的，但是对象的内部组成构件面临着复杂的变化。

2.要创建的复杂对象的算法，独立于该对象的组成部分，也独立于组成部分的装配方法时。

个人总结：

1、建造者模式更像是一套工作车间，它负责产品各个部件的组装，客户端无须知道具体的建造过程，只需要拿到相应的产品即可，大大简化了代码的耦合度；

2、说白了，建造者模式侧重的是一个建造者类的内部逻辑，而外观模式侧重的是各个子类之间的逻辑，区别很大

3、建造者类是要有具体的建造对象生成的，即产品；外观模式没有这一点要求