设计模式 --- Builder模式

1.定义

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

2.使用场景

1.相同的方法，不同的执行顺序，产生不同的结果。

2.多个部分都可以装配到一个对象中，但产生的结果又不相同。

3.产品类非常复杂，或者产品类的调用顺序不同产生了不同的作用。

4.初始化一个对象特别复杂，参数多，且很多参数具有默认值。

3.简单实现

将计算机的组装简化为构建主机、设置操作系统、设置显示3个部分，然后通过Director和具体的Bulider来构建计算机对象。

//计算机抽象类
public abstract class Computer{
    protected String mBoard;
    protected String mDisplay;
    protected String mOs;
    protected Computer(){}

    //构建主机
    public void setmBoard(String board){ mBoard = board; }
    //设置显示
    public void setmDisplay(String display){ mDisplay = display; }
    //设置系统
    public abstract void setmOs();

    @Override
    public String toString() {
        return "Computer -> Board:" + mBoard +" Display:"+ mDisplay +" OS:" + mOs;
    }
}

//具体计算机类 Mac
public class MacBook extends Computer{
    protected MacBook(){}

    @Override
    public void setmOs() {
        mOs = "Mac OS X 10.01";
    }
}

//抽象Builder类
public abstract class Builder{
    //构建主机
    public abstract void buliderBoard(String board);
    //设置显示
    public abstract void builderDisplay(String display);
    //设置操作系统
    public abstract void builderOs();
    //创建Computer
    public abstract Computer create();
}

//具体Builder类
public class MacBookBuilder extends Builder{
    private  Computer computer = new MacBook();

    @Override
    public void buliderBoard(String board) { computer.setmBoard(board); }

    @Override
    public void builderDisplay(String display) { computer.setmDisplay(display);}

    @Override
    public void builderOs() { computer.setmOs();}

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

//Director 负责构建Computer
public class Director{
    Builder mBuilder = null;
    public Director(Builder builder){ mBuilder = builder; }
    //构建对象
    public void constrcut(String board,String display){
        mBuilder.builderDisplay(display);
        mBuilder.buliderBoard(board);
        mBuilder.builderOs();
    }
}

public  class Test{
    public static void main(String[] args){
        //构建器
        Builder builder = new MacBookBuilder();
        //Director
        Director director = new Director(builder);
        //构建一个 因特尔主板 Retina显示器 的Mac电脑
        director.constrcut("英特尔","Retina");
        System.out.print(builder.create().toString());
        
    }
}

示例通过具体的MacBulider构建MacBook对象，Director封装了构建产品对象的过程，对外隐藏细节。

在实际开发中Director通常被省略，直接使用一个Bulider来进行对象的组装，这个Builder通常为链式调用，实现方式是在每个setter方法中返回自身，这种形式使结构更加简洁直观，也能多组装的过程又更精细的控制。

只需要将Director类删除，修改抽象Bulider类方法返回自身，如下

//抽象Builder类
public abstract class Builder{
    //构建主机
    public abstract Builder buliderBoard(String board);
    //设置显示
    public abstract Builder builderDisplay(String display);
    //设置操作系统
    public abstract Builder builderOs();
    //创建Computer
    public abstract Computer create();
}

//具体Builder类
public class MacBookBuilder extends Builder{
    private  Computer computer = new MacBook();

    @Override
    public Builder buliderBoard(String board) {
        computer.setmBoard(board);
        return this;
    }

    @Override
    public Builder builderDisplay(String display) {
        computer.setmDisplay(display);
        return this;
    }

    @Override
    public Builder builderOs() {
        computer.setmOs();
        return this;
    }

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

public  class Test{
    public static void main(String[] args){
        //构建器
        Builder builder = new MacBookBuilder();
        //构建一个 因特尔主板 Retina显示器 的Mac电脑
        //链式调用
        Computer mComputer = builder.buliderBoard("因特尔").builderDisplay("Retina").builderOs().create();
        System.out.print(mComputer.toString());

    }
}

4.小结

Builder模式通常作为配置类的构建器将配置的构建和表示分离出来，同时也是将配置从目标类中隔离。通常使用链式调用的方法，使得代码更简洁易懂。

优点：

1.良好的封装性，使用户不必知道内部组成的细节。

2.建造着独立，容易拓展。

缺点：

1.会产生多余的Builder对象，消耗内存。

2.对于某些必须设置的参数一定设定好默认值，否则代码编译能通过 而实际运行中会报错