设计模式__建造者模式

定义: 将一个复杂对象的构建和表示分离，使得他的同一个构建可以有不同的表示。（主要是对产品的封装，强调构建和表示）

适合场景：1. 一个复杂产品，不同方法使用顺序不同，表示不同；

                 2. 一个产品构建是参数较多；

                 3. 需要对一个比较复杂的对象进行封装；

接着之前的主题，封装一个主题。主题中的好多方法使用顺序不同，表示不同。

1.构建主题产品；

/**
 * 主题 （产品）
 */
public class Theme {

    public String aBg;

    public String btnBg;

    public String textColor;

    public String orderColor;

    public String getaBg() {
        return aBg;
    }

    public void setaBg(String aBg) {
        this.aBg = aBg;
    }

    public String getBtnBg() {
        return btnBg;
    }

    public void setBtnBg(String btnBg) {
        this.btnBg = btnBg;
    }

    public String getOrderColor() {
        return orderColor;
    }

    public void setOrderColor(String orderColor) {
        this.orderColor = orderColor;
    }

    public String getTextColor() {
        return textColor;
    }

    public void setTextColor(String textColor) {
        this.textColor = textColor;
    }

    @Override
    public String toString() {
        return "Status{" +
                "aBg='" + aBg + '\'' +
                ", btnBg='" + btnBg + '\'' +
                ", textColor='" + textColor + '\'' +
                ", orderColor='" + orderColor + '\'' +
                '}';
    }

}

2.建造者：（封装产品的构建）

public abstract class Builder<P> {

    public P prodect;

    public abstract void setaBg();

    public abstract void setBtnbg();

    public abstract void setTextColor();

    public abstract void setOrderColor();

    public abstract P createProduct();

}

3.建造者实现：

public class RedBuilder extends Builder<Theme> {

    public RedBuilder() {
        this.prodect = new Theme();
    }

    @Override
    public void setaBg() {
        this.prodect.setaBg("整体红色！");
    }

    @Override
    public void setBtnbg() {
        this.prodect.setBtnBg("蓝色按钮!");
    }

    @Override
    public void setTextColor() {
        this.prodect.setTextColor("文字颜色！");
    }

    @Override
    public void setOrderColor() {
        this.prodect.setOrderColor("特定的颜色！");
    }

    @Override
    public Theme createProduct() {
        return prodect;
    }
}

4.指挥者：

/**
 * 指挥者
 */
public class Director {

    public Theme create(Builder builder) {
        builder.setaBg();
        builder.setBtnbg();
        builder.setTextColor();
        builder.setOrderColor();
        return (Theme) builder.createProduct();
    }
}

最后使用：

Builder builder = new RedBuilder();
        Director director = new Director();
        Theme theme = director.create(builder);
        System.out.print(theme.toString());

builder和director使得产品的构建和表示分离了，使得一个建造可以有不同的表示。

当然，一般建造者的使用弱化了director，将方法的使用顺序交给使用者。但是，已经将产品封装很好，产品创建完之后，不能再更改，使用者也不会因为产品方法太多而烦恼。

代码如下：

public class RedBuilder extends Builder<Theme> {

    private String aBg;
    private String btnBg;
    private String textColor;
    private String orderColor;

    public RedBuilder() {
    }

    @Override
    public Builder setaBg() {
        aBg = "整体红色！";
        return this;
    }

    @Override
    public Builder setBtnbg() {
        btnBg = "蓝色按钮!";
        return this;
    }

    @Override
    public Builder setTextColor() {
        textColor = "文字颜色！";
        return this;
    }

    @Override
    public Builder setOrderColor() {
        orderColor = "特定的颜色！";
        return this;
    }

    private void config(Theme theme){
        theme.setaBg(aBg);
        theme.setBtnBg(btnBg);
        theme.setTextColor(textColor);
        theme.setOrderColor(orderColor);
    }

    @Override
    public Theme createProduct() {
        Theme theme=new Theme();
        config(theme);
        return theme;
    }
}

使用的时候

        Theme theme = (Theme) new RedBuilder()
                .setaBg()
                .setBtnbg()
                .setOrderColor()
                .setOrderColor()
                .createProduct();
        System.out.print(theme.toString());

当然，以上实现最好用内部类实现，产品的方法私有化。完美！