Java设计模式-Builder模式

Java设计模式-Builder模式

定义：

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

应用场景：

1. 相同的方法，不同的执行顺序，产生不同的事件结果时
2. 多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时
3. 产品类非常复杂，或者产品类中的调用顺序不同产生了不同的作用
4. 当初始化一个对象特别复杂，如参数多，且很多参数都具有默认值时

Buider模式的简单实现

public abstract class Computer {
    protected String mBoard;
    protected String mDisplay;
    protected String mOS;

    protected Computer(){}

    //设置CPU核心数
    public void setBoard(String board){
        mBoard = board;
    }

    //设置内存
    public void setDisplay(String display){
        mDisplay = display;
    }

    //设置操作系统
    public abstract void setOS();

    @Override
    public String toString() {
        return "Computer{" +
                "mBoard='" + mBoard + '\'' +
                ", mDisplay='" + mDisplay + '\'' +
                ", mOS='" + mOS + '\'' +
                '}';
    }
}

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();
}

public class MacBookBuilder extends Builder {
    private Computer computer = new MacBook();
    @Override
    public void buildBoard(String board) {
        computer.setBoard(board);
    }

    @Override
    public void buildDisplay(String display) {
        computer.setDisplay(display);
    }

    @Override
    public void buildOS() {
        computer.setOS();
    }

    @Override
    public Computer create() {
        return computer;
    }
}

//Director类，负责构造Computer
public class Director {
    Builder builder = null;

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

    public void construct(String board,String display){
        builder.buildBoard(board);
        builder.buildDisplay(display);
        builder.buildOS();
    }
}

public class Test {
    public static void main(String[] args) {
        Builder builder = new MacBookBuilder();
        Director director = new Director(builder);
        director.construct("英特尔主板","Retina显示器");
        System.out.println(builder.create());
    }
}

上述示例中，通过具体的MacBookBuilder来构建MacBook对象，而Director封装了构建复杂产品对象的过程，对外隐藏构建细节。Builder与Director一起将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的对象。