建造者（Builder）模式——Java设计模式（四）

建造者模式简介

建造者模式（Builder Pattern）：使用多个简单的对象一步一步构建成一个复杂的对象。

分类：创建型模式。

一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

主要解决：

1. 在软件系统中，有时候面临着”一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；
2. 由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

何时使用：一些基本部件不会变，而其组合经常变化的时候。

如何解决：将变与不变分离开。

关键代码：

1. 建造者：创建和提供实例；
2. 导演：管理建造出来的实例的依赖关系。

应用实例：

1. 去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的”套餐”。
2. JAVA 中的 StringBuilder。

优点：

1. 建造者独立，易扩展。
2. 便于控制细节风险。

缺点：

1. 产品必须有共同点，范围有限制。
2. 如内部变化复杂，会有很多的建造类。

使用场景：

1. 需要生成的对象具有复杂的内部结构。
2. 需要生成的对象内部属性本身相互依赖。

角色结构

抽象建造者（Builder）：给出一个抽象结论，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的那些部分的创建，并不涉及具体的对象部件的创建。
具体建造者（ConcreteBuilder）：实现Builder接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。在构造过程完成后，提供产品的实例。
指导者（Director）：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。
产品类（Product）：要创建的复杂对象。

具体实现

建造一个汽车。需要先建造汽车的发动机、底盘、车身和电气设备。然后对其进行组装。

步骤一：给出产品类。即，要创建的复杂对象。

/**
 * 产品类——汽车
 * 汽车由发动机、底盘、车身、电气设备组成。
 * @author Administrator
 *
 */
public class Car {
    private String engine;//发动机
    private String chassis;//汽车底盘
    private String body;//车身
    private String electricEquipment;//汽车的电气设备

    public String getEngine() {
        return engine;
    }

    public void setEngine(String engine) {
        this.engine = engine;
    }

    public String getChassis() {
        return chassis;
    }

    public void setChassis(String chassis) {
        this.chassis = chassis;
    }

    public String getBody() {
        return body;
    }


    public void setBody(String body) {
        this.body = body;
    }

    public String getElectricEquipment() {
        return electricEquipment;
    }

    public void setElectricEquipment(String electricEquipment) {
        this.electricEquipment = electricEquipment;
    }
}

步骤二：给出抽象建造者。

/**
 * 抽象建造者-汽车建造者
 * @author Administrator
 *
 */
public interface ICarBuilder {
    Car builderCar(); //建造汽车

    void builderEngine();//建造汽车发动机
    void builderChassis();//建造汽车底盘
    void builderBody();//建造车身
    void builderElectricEquipment();//建造汽车的电气设备
}

步骤三：通过实现抽象建造者，给出具体建造者。

/**
 * 具体建造者-具体汽车建造者。
 * @author Administrator
 *
 */
public class CarBuilder implements ICarBuilder {
    private Car car;

    public CarBuilder() {
        car = new Car();//建造一个汽车
    }

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

    @Override
    public void builderEngine() {
        System.out.println("建造一个汽车发动机");
    }

    @Override
    public void builderChassis() {
        System.out.println("建造一个汽车底盘");
    }

    @Override
    public void builderBody() {
        System.out.println("建造一个汽车车身");
    }

    @Override
    public void builderElectricEquipment() {
        System.out.println("建造一个汽车电气设备");
    }
}

步骤四：给出指导者。即，具体实现复杂产品的类。

/**
 * 指导者-具体的实现汽车的构造，然后进行汽车的组装。
 * @author Administrator
 *
 */
public class CarDirector {

    public Car constructCar(CarBuilder carBuilder) {
        carBuilder.builderEngine();
        carBuilder.builderChassis();
        carBuilder.builderBody();
        carBuilder.builderElectricEquipment();

        return carBuilder.builderCar();
    }
}

步骤五：测试。

/**
 * 测试类。
 * @author Administrator
 *
 */
public class Test {
    public static void main(String[] args) {
        CarDirector cd = new CarDirector();
        Car car = cd.constructCar(new CarBuilder());
    }
}

步骤六：验证结果。

建造一个汽车发动机
建造一个汽车底盘
建造一个汽车车身
建造一个汽车电气设备