Java/Android设计模式之 Builder设计模式,构建者模式

在众多的设计模式中构建者模式Builder显得非常的精妙，它能在用户不知道内部情况下创建一个对象，也就是省略部分细节，显得简洁大方。今天我们开始介绍这个构建者模式

首先是对象，我们需要生成的对象，这里我们是一个抽象的产品类，其中操作系统需要具体的实现类去操作

//计算机,也就是产品类
public abstract class Computer {
    protected String mBoard;
    protected String mDisplay;
    protected String mOS;

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

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



    public abstract void setmOS();


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

具体的产品类,实现了抽象的产品Computer

//具体的产品类
public class Macbook extends Computer {
    protected Macbook() {
    }

    @Override
    public void setmOS() {
        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();
    public abstract Computer create();
}

具体的构造者 这里首先new出来了一个对象，实现抽象的Builder，在builder方法；里面为computer设置相关的属性，最后create方法返回这个对象

//具体的Builder类 MacBookBuilder
public class MacBookBuilder extends Builder{
    private Computer mComputer = new Macbook();

    @Override
    public void buildBoard(String board) {
        mComputer.setmBoard(board);
    }

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

    @Override
    public void buildOS() {
            mComputer.setmOS();
    }

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

Director类，负责构造，首先用户在初始化这个类的时候需要传递一个Builder过来，一般是传递一个具体的Builder过来再调用construct这个方法就完成了产品的生成，在最后调用builder.create()就可以生成这个对象

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

    public Director(Builder mBuilder) {
        this.mBuilder = mBuilder;
    }
    /**
     * 构建对象
     */
    public void consttuct(String board, String display){
        mBuilder.buildBoard(board);
        mBuilder.buildDisplay(display);
        mBuilder.buildOS();
    }
}

测试类

public class Main {

    public static void main(String[] args) {
    //初始化一个具体的Mac电脑的构造Builder，在这里面已经设置了系统,这里保存了一个没有配置的电脑产品
        Builder  builder = new MacBookBuilder();
        //初始化一个构建类，这个构建类里面需要builder参数
        Director pcDirector = new Director(builder);
        //这个构建类就可以开始构造我们需要配置的产品
        pcDirector.consttuct("英特尔", "Retina显示器");
        //最后我们调用builder的create()方法就可以生成一个对象
        System.out.println("Computer info :"+ builder.create().toString());
    }
}

在这里是比较简单的构造者模式的设计形式，在android的对话框中我们经常会使用到这种设计模式。