设计模式---Builder模式

　　定义：将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

　　使用场景：
　　①相同的方法，不同的执行顺序会导致不同的运行结果。
　　②初始化一个对象特别复杂（参数多、很多参数具有默认值）。
　　③多个“部件”或“零件”都可以装配到一个对象中，但是产生的运行结果却不同。

　　经典的UML图：
　　
　　
　　简单实现：

//产品类
public class Computer{
    //主板
    private String board;
    //显示屏
    private String display;

    public void setBoard(String board){
        this.board = board;
    }

    public void setDisplay(String display){
        this.display = display;
    }

    public String getBoard(){
        return this.board;
    }

    public String getDisplay(){
        return this.display;
    }
}

//抽象Builder类
public abstract class Builder{

    public abstract Builder setBoard(String board);

    public abstract Builder setDisplay(String display);

    public abstract Computer build();
}

//具体Builder类
public class ConcreteBuilder extends Builder{

    private Computer computer = new Computer();

    @Override
    public abstract Builder setBoard(String board){
        computer.setBoard(board);
        return this;
    }

    @Override
    public abstract Builder setDisplay(String display){
        computer.setDisplay(display);
        return this;
    }

    @Override
    public abstract Computer build(){
        return this.computer;
    }
}

//指挥者
public class Director{

    private Builder builder = null;

    public Director(Builder builder){
        this.builder = builder;
    }

    public void construct(String board,String display){
        builder.setBoard(board)
               .setDisplay(display);
    }
}

public class Text{
    public static void main(String[] args){
        Builder builder = new ConcreteBuilder();
        Director director = new Director(builder);

        director.construct("因特尔","Retina显示器");

        Computer computer = builder.build();

        System.out.println("主板：" + computer.getBoard() + "显示器:" + computer.getDisplay());
    }
}

　　这里边可以发现Builder与Director将Computer的构建与表示分开了。只需要改变具体的Builder与Director我们就可以生产出不同的Computer。

　　Builder模式特点：链式调用，即每个set方法都返回自身（return this）。

　　安卓开发中常用的Builder模式：AlertDialog的使用。但并不是按照经典的模式实现的，常常我们在使用该模式时会采用内部类这种方式来实现：

//产品类
public class Computer{
    //主板
    private String board;
    //显示屏
    private String display;

    public String getBoard(){
        return this.board;
    }

    public String getDisplay(){
        return this.display;
    }

    //内部类
    public class Builder{
        //主板
        private String board = "Inter i5";
        //显示屏
        private String display = "Retina";

        private Computer computer = null;

        public Builder setBoard(String board){
            this.board = board;
            return this;
        }

        public Builder setDisplay(String display){
            this.display = display;
            return this;
        }

        public Computer build(){
            computer = new Computer();
            computer.board = this.board;
            computer.display = this.display;

            return computer;
        }
    }
}

public class Text{
    public static void main(String[] args){
        Computer.Builder builder = new Computer.ConcreteBuilder();
        builder.setBoard("Inter主板")
               .setDisplay("显示器");

        Computer computer = builder.build();

        System.out.println("主板：" + computer.getBoard() + "显示器:" + computer.getDisplay());
    }
}

　　Builder模式最大的好处：对于复杂对象的构建，用户只需设置一些所关心的参数便可以构造出一个完整对象，构造简单。而不用担心因构造顺序、构造所需要的所有参数对最终结果的影响。内部的实现对用户完全透明。