building--构建者模式

又到一个新的模式了，坚持三两天一个模式吧。好了， 不多扯这没用的了，正式来学习我们的构建者模式。

1、使用场景：

我觉得是在其它类中不关心构建过程，在初始化之前或在初始化时需要大量设置、调用属性或方法时使用。

来自百度文库：

缺点：

建造者模式的“加工工艺”是暴露的，这样使得建造者模式更加灵活，也使得工艺变得对客户不透明。

优点：

  建造模式的使用使得产品的内部表象可以独立地变化。使用建造模式可以使客户端不必知道产品内部组成的细节。 
每一个Builder都相对独立，而与其他的Builder无关。 模式所建造的最终产品更易于控制。

理解：

以一个造车与造船为本次的模式做理解，客户需要一辆车，和一只船做为交通工具。此时，客户是不需要知道车与船是如何制造出来的，客户只是关心需要得到车和船。

一辆能运行的车或船只应该有发动机和燃料（如果读者要钻牛角尖，那我也无能为力啦），制造发动机是需要材料与工人的，对车来说，它只是需要发动机与燃料。所以在我们的构建者中需要为车准备材料与工人。管理员，对构建车或船做管理。

UML图：

对应代码：

首先我们需要一个构建交通工具的抽象类（也可以是接口）

public abstract class AbstractTrafficToolsBuilding {

    protected ITrafficTools trafficTools;
    public abstract void buildingMaterial();
    public abstract void buildingWorker();
    public abstract ITrafficTools resultTrafficTools();

}

两个具体实现类：

public class CarBuilding extends AbstractTrafficToolsBuilding {

    public CarBuilding(){
        this.trafficTools = new Car();
    }
    @Override
    public void buildingMaterial() {
        System.out.println("找到安装车的材料....");
    }

    @Override
    public void buildingWorker() {
        System.out.println("找到安装车的工人...");
    }

    @Override
    public ITrafficTools resultTrafficTools() {
        trafficTools.engine();
        trafficTools.elding();
        System.out.println("车辆完工...");
        return trafficTools;
    }
}

public class ShipBuilding extends AbstractTrafficToolsBuilding {

    public ShipBuilding(){
        this.trafficTools = new Ship();
    }
    @Override
    public void buildingMaterial() {
        System.out.println("找到安装船的材料....");
    }

    @Override
    public void buildingWorker() {
        System.out.println("找到安装船的工人...");
    }

    @Override
    public ITrafficTools resultTrafficTools() {
        trafficTools.engine();
        trafficTools.elding();
        System.out.println("船只完工...");
        return trafficTools;
    }
}

交通工具的接口，一个发动机，一个燃料的方法。

public interface ITrafficTools {
    public void engine();
    public void elding();
}

两个实现类：

public class Car implements ITrafficTools{
    @Override
    public void engine() {
        System.out.println("安装车的发动机...");
    }

    @Override
    public void elding() {
        System.out.println("给车加入燃料...");
    }
}

public class Ship implements ITrafficTools {
    @Override
    public void engine() {
        System.out.println("安装船的发动机...");
    }

    @Override
    public void elding() {
        System.out.println("给船加入燃料...");
    }
}

最后是我们的管理者：

public class Director {
    public Director(AbstractTrafficToolsBuilding abstractTrafficToolsBuilding){
        this.abstractTrafficToolsBuilding = abstractTrafficToolsBuilding;
    }
    private AbstractTrafficToolsBuilding abstractTrafficToolsBuilding;

    public ITrafficTools construct(){
        abstractTrafficToolsBuilding.buildingMaterial();
        abstractTrafficToolsBuilding.buildingWorker();
        return abstractTrafficToolsBuilding.resultTrafficTools();
    }
}

客户调用：

public class Client {
    public static void main(String[] args) {
        //得一个辆车
        Director director = new Director(new CarBuilding());
        ITrafficTools car = director.construct();
        //得到一只船
        Director shipDirector = new Director(new ShipBuilding());
        ITrafficTools ship = shipDirector.construct();
    }
}

在客户端，我们完全不知道在构建交通工具时发生了什么（调用了哪此方法，设置了哪些属性），我们只关心，我们可以得到自己想要的交通工具了。

这就是构建者模式。