建造者模式

定义：将一个复杂对象的构造与它的表示分离(ConcreteBuilder 负责表示，Director负责构建)，使同样的构建过程(Director可以构建不同的对象)可以创建不同的表示，这样的设计模式被称为建造者模式。（常与模板模式一起使用）

使用场景： 1、当对象的构建过程十分复杂，需要与表示分离的时候。

                   2、当对象的表示有不同种类，需要加以区分的时候

优点：1.可以很方便构建的对象 

           2.对象的构造统一在一起构造,客户不关注构造过程。

           3.更加方便的替换和新增产品，不用修改原代码(只需要提供对象内容)。

缺点：1.不适合创建差异性很大的产品类。

           2.需要生成的产品对象有复杂的内部结构，这些产品对象具备共性。

类图：

结构

product需要的复杂对象

public class Product 
{
    private String A; //可以是任意类型
    private String B;
    private String C;
    private String D;
    //get set方法

}

Builder类

public abstract class Builder
{
    protected Product product=new Product();

    public abstract void buildA();
    public abstract void buildB();
    public abstract void buildC();

    public Product getResult()
    {
        return product;
    }
}

ConcreteBuilder 类

public class ConcreteBuilder extends Builder{
    public void buildPartA(){
    ...
    }
    public void buildPartB(){
    ...
    }
    public void buildPartC(){
    ...
    }
}

指挥者类

public class Director
{
    private Builder builder;
    //1 构造方法的方式注入builder对象
    public Director(Builder builder)
    {
        this.builder=builder;
    }
    //2 set方法注入builder对象
    public void setBuilder(Builder builder)
    {
        this.builder=builer;
    }

    public Product construct()
    {   
        //将存在的ConcreteBuilder 直接组装
        builder.buildPartA();
        builder.buildPartB();
        builder.buildPartC();
        return builder.getResult();
    }
}

具体栗子

要构建的具体对象

public class Person{

     //上衣
     private String jacket;

     //下装
     private String bottling;

     //戒子
     private String ring;

     //武器
     private String arms;

     //手镯
     private String bracelet;

     //鞋
     private String shoes;

     //get set方法

}

Builder类（一个抽象构造者，个人理解 需要一个抽象类实现多态的固定写法 应该也可以为接口 但是需要在每个实现类中增加共同的方法）

public abstract class PersonBuilder {
    Person person= new Person();

    public abstract void buildJacket();

    public abstract void buildBottling();

    public abstract void buildRing();

    public abstract void buildArms();

    public abstract void buildBracelet();

    public abstract void buildShoes();

    public Person getPerson(){
        return person;
    }
}

ConcreteBuilder类（现有的对象模型的种类）

public class ChargeMoney extends Person{

    public void buildJacket(){
       person.setJacket("金光闪闪上衣");
    };

    public void buildBottling(){
       person.setBottling("亮瞎眼的裤子");
    };

    public void buildRing(){
       person.setRing("钛合金戒子");
    };

    public void buildArms(){
       person.setArms("40米长大砍刀");
    };

    public void buildBracelet(){
       person.setArms("金溜子");
    };

    public void buildShoes(){
       person.setShoes("大头皮鞋");
    };
}

public class NoChargeMoney extends Person{

    public void buildJacket(){
       person.setJacket("花式囚衣");
    };

    public void buildBottling(){
       person.setBottling("三角裤头");
    };

    public void buildRing(){
       person.setRing("草戒子");
    };

    public void buildArms(){
       person.setArms("牙签");
    };

    public void buildBracelet(){
       person.setArms("柳树条");
    };

    public void buildShoes(){
       person.setShoes("10块钱三双拖鞋");
    };
}

Director(对类构造的整体控制，同时对客户隔绝)

public class GameGM{
    private PersonBuilder personBuilder ;

    public GameGM(PersonBuilder personBuilder ) {
        this.personBuilder = personBuilder ;
    }


    public Person construct(){
        //进行构造
        personBuilder.buildJacket();
        personBuilder.buildBottling();
        personBuilder.buildRing();
        personBuilder.buildArms();
        personBuilder.buildBracelet();
        personBuilder.buildShoes();

        //准备完毕，返回一个人员模型
        return personBuilder.getPerson();
    }
}

客户调用

public class Test {
    public static void main(String[] args) {
        //即可获取到对象
        ChargeMoney a = new ChargeMoney();
        GameGM gm = new GameGM(a);
        Meal mealA = gm.construct();      

    }
}