创建型设计-建造者模式

    声明一下：本文的文字多数文字都是来自网上，只有例子是自己写的。因为自我感觉还没有能力能够系统的解释一个模式，已经有现成的比较完善的说明，就不重复造轮子了。

     在软件系统中，有时候面临着“一个复杂对象”的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法确相对稳定。如何应对这种变化？如何提供一种“封装机制”来隔离出“复杂对象的各个部分”的变化，从而保持系统中的 “稳定构建算法”不随着需求改变而改变？这就是要说的建造者模式。

建造者类图：

建造的接口：

/**
 * 构造的接口
 */
public interface ICarBuilder {
    void buildTyre();
    void buildCarbody();
    void buildEngine();
    Car buildCar();
}

具体实现1：

/**
 * Created by Administrator on 2017/10/9.
 */
public class Car1_Builder implements ICarBuilder {
    Car car; // 定义对象
    public Car1_Builder(){
        car=new Car(); //实例化一个临时对象
    }
    @Override
    public void buildTyre() {
        car.setTyre("奥迪汽车轮胎");
    }
    @Override
    public void buildCarbody() {
        car.setCarbody("奥迪汽车的框架");
    }
    @Override
    public void buildEngine() {
        car.setEngine("奥迪汽车发动机");
    }
    @Override
    public Car buildCar() {
        return car;
    }
}

具体实现2：

public class Car2_Builder implements ICarBuilder {
    Car car;
    public Car2_Builder(){
        car=new Car();
    }
    @Override
    public void buildTyre() {
        car.setTyre("奔驰汽车轮胎");
    }
    @Override
    public void buildCarbody() {
        car.setCarbody("奔驰汽车的框架");
    }
    @Override
    public void buildEngine() {
        car.setEngine("奔驰汽车发动机");
    }
    /**
     * 返回组装对象
     * @return
     */
    @Override
    public Car buildCar() {
        return car;
    }
}

装配协调类：

/**
 * 负责分配
 */
public class CarDirector {
    public Car DirectorCar(ICarBuilder car){
        car.buildCarbody();
        car.buildEngine();
        car.buildTyre();
        return car.buildCar();
    }
}

实体类：

public class Car {
    private String tyre;
    private String carbody;
    private String engine;
    public String getTyre() {
        return tyre;
    }
    public void setTyre(String tyre) {
        this.tyre = tyre;
    }
    public String getCarbody() {
        return carbody;
    }
    public void setCarbody(String carbody) {
        this.carbody = carbody;
    }
    public String getEngine() {
        return engine;
    }
    public void setEngine(String engine) {
        this.engine = engine;
    }
}

调用者：（Client）

public class BuilderTest {
    public static void main(String[] args) {
        CarDirector cardirector=new CarDirector(); //实例化一个管理者
        Car car1=cardirector.DirectorCar(new Car1_Builder());//负责要组装的对象1
        Car car2=cardirector.DirectorCar(new Car2_Builder());//负责要组装的对象2
        System.out.println(car1.getCarbody());
        System.out.println(car1.getEngine());
        System.out.println(car1.getTyre());
        System.out.println("=========================");
        System.out.println(car2.getCarbody());
        System.out.println(car2.getEngine());
        System.out.println(car2.getTyre());
    }
}

结果：

奥迪汽车的框架

奥迪汽车发动机

奥迪汽车轮胎

====================

奔驰汽车的框架

奔驰汽车发动机

奔驰汽车轮胎

建造者模式的优点
        首先，建造者模式的封装性很好。使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在导演类中对整体而言可以取得比较好的稳定性。
        其次，建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。
 
建造者模式与工厂模式的区别
       我们可以看到，建造者模式与工厂模式是极为相似的，总体上，建造者模式仅仅只比工厂模式多了一个“导演类”的角色。在建造者模式的类图中，假如把这个导演类看做是最终调用的客户端，那么图中剩余的部分就可以看作是一个简单的工厂模式了。
       与工厂模式相比，建造者模式一般用来创建更为复杂的对象，因为对象的创建过程更为复杂，因此将对象的创建过程独立出来组成一个新的类——导演类。也就是说，工厂模式是将对象的全部创建过程封装在工厂类中，由工厂类向客户端提供最终的产品；而建造者模式中，建造者类一般只提供产品类中各个组件的建造，而将具体建造过程交付给导演类。由导演类负责将各个组件按照特定的规则组建为产品，然后将组建好的产品交付给客户端。