建造者模式 build

引出建造者模式：

package com.disign.build;

/**
 * Created by zhen on 2017-05-19.
 */
public class BuildPersonTest {
    /**
     * 吃面，面的口味与厨师的心情等关联引出：
     *  抽象不应该依赖于细节，细节应该依赖于抽象，吃的菜不能依赖于厨师的细节。
     *  构建小人
     *  防止哪次构建的时候小人少了哪个必要组件，应该使用抽象继承
     */
    public static void main(String[] args){

        Person thin = BuildPerson.build(new ThinPerson());
        Person fat = BuildPerson.build(new FatPerson());
    }

}
class BuildPerson{

    public static Person build(Person person){
        person.buildHead();
        person.buildBody();
        person.buildArmLeft();
        person.buildArmRight();
        person.buildLegLeft();
        person.buildLegRight();
        return person;
    }

}
abstract class Person{
   abstract void buildHead();
   abstract void buildBody();
   abstract void buildArmLeft();
   abstract void buildArmRight();
   abstract void buildLegLeft();
   abstract void buildLegRight();
}
class FatPerson extends Person{
    @Override
    void buildHead() {

    }

    @Override
    void buildBody() {

    }

    @Override
    void buildArmLeft() {

    }

    @Override
    void buildArmRight() {

    }

    @Override
    void buildLegLeft() {

    }

    @Override
    void buildLegRight() {

    }
}
class ThinPerson extends Person{
    @Override
    void buildHead() {

    }

    @Override
    void buildBody() {

    }

    @Override
    void buildArmLeft() {

    }

    @Override
    void buildArmRight() {

    }

    @Override
    void buildLegLeft() {

    }

    @Override
    void buildLegRight() {

    }
}

我们上面的代码就用到了建造者模式。

建造小人的过程是稳定的，都需要头身手脚，具体建造的细节不同，有高矮胖瘦。但是对于用户而言，我只告诉你，我需要一个胖小人，我们应该在保证一个正常人的前提下对人的细节进行修饰。

如果你需要将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示意图的时候，我们可以使用建造者模式，又叫生成器模式。如果我们用了建造者模式，用户只需要指定需要建造的类型就可以得到他们，具体的建造的过程和细节就不需要知道了。

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

图中Builder是什么？

为创建一个Product对象各个部件指定的抽象接口。

ConcreteBuilder是什么？

具体创造的，实现Builder接口，构造和装配各个部件。

Product是什么？

具体的小人，产品角色。

Director是什么？

指挥者，用来根据用户需求构建小人对象，是一个使用Builder接口的对象

什么时候使用构建者模式呢？

用于创建一些复杂的对象，这些对象内部构建之间的构造顺序通常是非常稳定的，单对象内部的构建通常面临着复杂的变化

构造者模式的好处就是使得构造代码与表示代码分离，由于构造者隐藏了该产品是如何组装的，所以弱需要改变一个产品的内部表示，只需要再定一个具体的建构者就可以了。

基本代码：

public class BuildProductTest {
    public static void main(String[] args){
        Director director = new Director();
        BuilderProduct builderProduct1 = new ConcreteBuilder1();
        BuilderProduct builderProduct2 = new ConcreteBuilder2();

        director.construct(builderProduct1);
        Product p1 = builderProduct1.getResult();
        p1.show();

        director.construct(builderProduct2);
        Product p2 = builderProduct2.getResult();
        p2.show();
    }
}
class Product{
    List<String> parts = new ArrayList<String>();
    public void add(String part){
        parts.add(part);
    }
    public void show(){
        for (String part: parts) {
            System.out.println(part);
        }
    }
}
abstract class BuilderProduct{
        public abstract void buildPartA();
        public abstract void buildPartB();
        public abstract Product getResult();
}
class ConcreteBuilder1 extends BuilderProduct{
    @Override
    public void buildPartA() {

    }

    @Override
    public void buildPartB() {

    }

    @Override
    public Product getResult() {
        return null;
    }
}
class ConcreteBuilder2 extends BuilderProduct{
    @Override
    public void buildPartA() {

    }

    @Override
    public void buildPartB() {

    }

    @Override
    public Product getResult() {
        return null;
    }
}
class Director{
    public void construct(BuilderProduct builder){
        builder.buildPartA();
        builder.buildPartB();
    }
}

建构者模式是在当创建复杂对象的算法应该独立于该对象的组成以及它们的装配方式时使用的模式。