定义

将一个杂乱目标的构建与它的表明别离，使得相同的构建进程能够创立不同的表明

运用场景

  1. 相同的办法，不同的执行次序，发生不同的事情成果时
  2. 多个部件或零件，都能够装配到一个目标中，但是发生的运行成果又不相同时
  3. 产品类非常杂乱，或者产品类中的调用次序不同发生可不同的效果
  4. 当初始化一个目标特别杂乱，如参数多，且很多参数都具有默认值时

UML类图

  • Product产品类——产品的笼统类
  • Builder——笼统Builder类，标准产品的组件，一般是由子类完成详细的组件进程
  • ConcreteBuilder——详细的Builder类
  • Director——一致的组装进程

设计模式：Builder模式

简略完成

//Product产品笼统类
//计算机笼统类
public abstract class Computer {
    protected String mBoard;
    protected String mDisplay;
    protected String mOS;
    protected Computer() {
    }
    //设置主板
    public void setBoard(String board) {
        this.mBoard = board;
    }
    //设置显示器
    public void setDisplay(String display) {
        this.mDisplay = display;
    }
    //设置操作系统
    public abstract void setOS();
    @Override
    public String toString() {
        return "Computer{" +
                "mBoard='" + mBoard + '\'' +
                ", mDisplay='" + mDisplay + '\'' +
                ", mOS='" + mOS + '\'' +
                '}';
    }
}
//Product产品完成类
//详细的Computer类：Macbook
public class Macbook extends Computer{
    protected Macbook(){
    }
    @Override
    public void setOS() {
        mOS="Mac OS X 10.10";
    }
}
//笼统的Builder
public abstract class Builder {
    //设置主板
    public abstract void buildBoard(String board);
    //设置显示器
    public abstract void buildDisplay(String display);
    //设置操作系统
    public abstract void buildOS();
    //创立Computer
    public abstract Computer create();
}
//Builder完成类
public class MacbookBuilder extends Builder{
    private Computer mComputer=new Macbook();
    @Override
    public void buildBoard(String board) {
        mComputer.setBoard(board);
    }
    @Override
    public void buildDisplay(String display) {
        mComputer.setDisplay(display);
    }
    @Override
    public void buildOS() {
        mComputer.setOS();
    }
    @Override
    public Computer create() {
        return mComputer;
    }
}
//Director类，负责结构Computer
public class Director {
    Builder mBuilder=null;
    public Director(Builder mBuilder) {
        this.mBuilder = mBuilder;
    }
    //结构目标
    public void construct(String board,String display){
        mBuilder.buildBoard(board);
        mBuilder.buildDisplay(display);
        mBuilder.buildOS();
    }
}

运用

public static void main(String[] args) {
    //构建器
    Builder builder=new MacbookBuilder();
    //Director
    Director director=new Director(builder);
    //封装构建进程
    director.construct("英特尔主板","Retina显示器");
    //构建计算机，输出相关信息
    System.out.println(builder.create().toString());
}

Director封装了构建杂乱产品目标的进程，对外躲藏构建细节

Builder和Director将一个杂乱目标的构建与它的表明别离，使得相同的构建进程能够创立不同的目标

实际开发中，一般省略Director人物

直接运用一个Builder来进行目标的组装，这个Builder一般为链式调用

要害点是每个setter办法都返回自身，使得setter办法能够链式调用。

public abstract class Builder {
    //设置主板
    public abstract Builder buildBoard(String board);
    //设置显示器
    public abstract Builder buildDisplay(String display);
    //设置操作系统
    public abstract void buildOS();
    //创立Computer
    public abstract Computer create();
}
public class MacbookBuilder extends Builder{
    private Computer mComputer=new Macbook();
    @Override
    public Builder buildBoard(String board) {
        mComputer.setBoard(board);
        return this;
    }
    @Override
    public Builder buildDisplay(String display) {
        mComputer.setDisplay(display);
        return this;
    }
    @Override
    public void buildOS() {
        mComputer.setOS();
    }
    @Override
    public Computer create() {
        return mComputer;
    }
}

链式运用：

public static void main(String[] args) {
    //构建器
    Builder builder=new MacbookBuilder();
    builder.buildBoard("英特尔主板").buildDisplay("Retina显示器").create();
}