Builder的介绍：
Builder模式是 一步一步创建一个复杂对象的创建型模式，它允许用户在不知道内部构建细节的情况下，可以更精细地控制对象的构造流程。该模式是为了将构建复杂对象的过程和它的部件解耦，使得构建过程和部件的表示隔离开来。
Builder模式的定义：
将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
对于android中 有个AlertDialog.Builder的使用想必大家都知道怎么用，这就是使用Builder来构建复杂的AlertDialog对象。例如下面的代码
//显示基本的AlertDialog
private void showDialog(Context context) {
AlertDialog.Builder builder = new AlertDialog.Builder(context);
builder.setIcon(R.drawable.icon);
builder.setTitle("Title");
builder.setMessage("Message");
builder.setPositiveButton("Button1",
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int whichButton) {
setTitle("点击了对话框上的Button1");
}
});
builder.setNeutralButton("Button2",
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int whichButton) {
setTitle("点击了对话框上的Button2");
}
});
builder.setNegativeButton("Button3",
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int whichButton) {
setTitle("点击了对话框上的Button3");
}
});
builder.create().show(); // 构建AlertDialog， 并且显示
}
创建完之后的对话框效果如图：
1.png
Builder模式的好处就是
1，良好的封装性， 使用建造者模式可以使客户端不必知道产品内部组成的细节；
2，建造者独立，容易扩展；
3，在对象创建过程中会使用到系统中的一些其它对象，这些对象在产品对象的创建过程中不易得到。
从代码的结构上也是看起来很顺眼。
但是
所以 Builder模式的使用场景，一般如下：
1，相同的方法，不同的执行顺序，产生不同的事件结果时；
2，多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时；
3，产品类非常复杂，或者产品类中的调用顺序不同产生了不同的效能，这个时候使用建造者模式非常合适；
4，当初始化一个对象特别复杂，如参数多，且很多参数都具有默认值时。
下面以组装电脑为例来演示一下简单且经典的builder模式。
package com.sx.test.builder;
/**
* Computer产品抽象类, 为了例子简单, 只列出这几个属性
*
* @author mrsimple
*/
public abstract class Computer {
protected int mCpuCore = 1;
protected int mRamSize = 0;
protected String mOs = "Dos";
protected Computer() {
}
// 设置CPU核心数
public abstract void setCPU(int core);
// 设置内存
public abstract void setRAM(int gb);
// 设置操作系统
public abstract void setOs(String os);
@Override
public String toString() {
return "Computer [mCpuCore=" + mCpuCore + ", mRamSize=" + mRamSize + ", mOs=" + mOs + "]";
}
}
package com.sx.test.builder;
/**
* Apple电脑
*/
public class AppleComputer extends Computer {
protected AppleComputer() {
}
@Override
public void setCPU(int core) {
mCpuCore = core;
}
@Override
public void setRAM(int gb) {
mRamSize = gb;
}
@Override
public void setOs(String os) {
mOs = os;
}
}
package com.sx.test.builder;
/**
* builder抽象类
*
*/
public abstract class Builder {
// 设置CPU核心数
public abstract void buildCPU(int core);
// 设置内存
public abstract void buildRAM(int gb);
// 设置操作系统
public abstract void buildOs(String os);
// 创建Computer
public abstract Computer create();
}
package com.sx.test.builder;
public class ApplePCBuilder extends Builder {
private Computer mApplePc = new AppleComputer();
@Override
public void buildCPU(int core) {
mApplePc.setCPU(core);
}
@Override
public void buildRAM(int gb) {
mApplePc.setRAM(gb);
}
@Override
public void buildOs(String os) {
mApplePc.setOs(os);
}
@Override
public Computer create() {
return mApplePc;
}
}
package com.sx.test.builder;
public class Director {
Builder mBuilder = null;
/**
*
* @param builder
*/
public Director(Builder builder) {
mBuilder = builder;
}
/**
* 构建对象
*
* @param cpu
* @param ram
* @param os
*/
public void construct(int cpu, int ram, String os) {
mBuilder.buildCPU(cpu);
mBuilder.buildRAM(ram);
mBuilder.buildOs(os);
}
}
package com.sx.test.builder;
public class Test {
public static void main(String[] args) {
// 构建器
Builder builder = new ApplePCBuilder();
// Director
Director pcDirector = new Director(builder);
// 封装构建过程, 4核, 内存2GB, Mac系统
pcDirector.construct(4, 2, "Mac OS X 10.9.1");
// 构建电脑, 输出相关信息
System.out.println("Computer Info : " + builder.create().toString());
}
}
结果输出：Computer info : Computer [mCpuCore=4, mRamSize=2, mOs=Mac OS X 10.9.1]
上述示例中，通过具体的ApplePCBuilder来构建AppleComputer对象，而Director封装了构建复杂产品对象的过程，对外隐藏构建细节。Builder与Director一起将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的对象。
不过在现实开发中，Director角色经常会被省略。而直接使用一个Builder来进行对象的封装，这个Builder通常为链式调用，他的关键点是每个setter方法都返回自身，也就是return this，这样使得setter方法可以链式调用，代码大致如下：
new TestBuilder().setA("A").setB("B").create();
通过这种形式不仅去除了Director角色，整个结构也更加简单，也能对Product对象的组装过程有更精细的控制。
网友评论