建造者模式

Builder Pattern#

一个 Builder 类会一步一步构造最终的对象，该 Builder 类是独立于其他对象的

主要解决#

有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化

这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定

与工厂模式的区别是：建造者模式更加关注与零件装配的顺序

例子 转自https://www.runoob.com/w3cnote/builder-pattern.html#

Computer.java

public abstract class Computer {
    protected String mBoard;
    protected String mDisplay;
    protected String mOs;
 
    protected Computer(){
    }
 
    public void setBoard(String board){
        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 + '\'' +
                '}';
    }
}

MacBook.java

public class MacBook extends Computer{

    protected MacBook() {
    }
 
    @Override
    public void setOs() {
        mOs="Mac OS X 12";
    }
}

Builder.java

public abstract class Builder {
 
    abstract void buildBoard(String board);
    abstract void buildDisplay(String display);
    abstract void buildOs();
    abstract Computer build();
}

MacBookBuilder.java

public class MacBookBuilder extends Builder {
 
    private Computer mComputer=new MacBook();
    @Override
    void buildBoard(String board) {
        mComputer.setBoard(board);
    }
 
    @Override
    void buildDisplay(String display) {
        mComputer.setDisplay(display);
    }
 
    @Override
    void buildOs() {
        mComputer.setOs();
    }
 
    @Override
    Computer build() {
        return mComputer;
    }
}

Director.java

public class Director {
    Builder mBuilser=null;
 
    public Director(Builder builer) {
        this.mBuilser = builer;
    }

    public void construct(String board,String display){
        mBuilser.buildDisplay(display);
        mBuilser.buildBoard(board);
        mBuilser.buildOs();
    }
}

Test.java

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

为了灵活构造复杂对象，该对象会有多个成员变量，在外部调用的时候，不需要或者不方便一次性创建出所有的成员变量

在这种情况下，使用多个构造方法去构建对象，很难维护，这时候Builder设计模式解决这个问题，进行buid()方法中创建对象

并且将builder传入，该builder中，维护了传入对象的成员变量