建造者模式
定义
将一个复杂对象的构建与它的标示分离,使得同样的构建过程可以创建不同的标示。
简介
- 建造者模式使用的目的是构造复杂对象,如果对象内部不是很复杂或者功能不是很多,是没有必要使用建造者模式的
- 使用者可以不用关心建造的过程和细节,只要使用对外提供的公共方法来构造对象即可。
- 关于建造者模式的使用,基本有两类方式,一种是传统的外部Builder类的方式,一般是使用静态内部类Builder的方式去构造对象。
传统Builder模式
1. 成员
- 1.产品类;
- 2.抽象的Builder类;
- 3.Builder实现类;
- 4.使用者;
2. 实例
我们使用建造者模式的目的,是创建复杂对象,那么首先,我们就需要这个复杂的对象,即产品类
public class Product{
private int param1;
private int param2;
private int param3;
private int param4;
private int param5;
private int param6;
/**
/* getter and setter
**/
...
@Override
public String toString() {
return ""+param1+param2+param3+param4+param5+param6;
}
}
接下来是此模式的核心——抽象Builder类(接口)
public interface Builder{
void setParam1();
void setParam2();
void setParam3();
void setParam4();
void setParam5();
void setParam6();
Product getProduct();
}
接下来就需要我们的实现类
public class BuilderImpl implements Builder{
private Product product;
public BuilderImpl(){
this.product = new Product();
}
@Override
public void setParam1(){
product.setParam1(1);
}
@Override
public void setParam2(){
product.setParam2(2);
}
@Override
public void setParam3(){
product.setParam3(3);
}
@Override
public void setParam4(){
product.setParam4(4);
}
@Override
public void setParam5(){
product.setParam5(5);
}
@Override
public void setParam6(){
product.setParam6(6);
}
@Override
public Product getProduct() {
return product;
}
}
最后我们实现一下使用类
public class Use{
private Builder builder;
public void setBuilder(Builder builder){
this.builder = builder;
}
public void createComputer(){
builder.setParam1();
builder.setParam2();
builder.setParam3();
builder.setParam4();
builder.setParam5();
builder.setParam6();
}
public Product getProduct(){
return builder.getProduct();
}
}
3.使用
public class Test{
public static void main(String[] args){
Use use = new Use();
use.setBuilder(new BuilderImpl ());
use.createProduct();
log.i("Product",use.toString());
}
}
输出:
Product:"21"
改革Builder模式 —— 静态内部类Builder
1.成员
只有产品类和内部Builder类
public class Product{
public static class Builder{
}
}
2.实例
public class Product{
private final String param1;
private final String param2;
private final String param3;
private Product(Builder builder){
this.param1 = builder.param1;
this.param2 = builder.param2;
this.param3 = builder.param3;
}
public static class Builder{
private final String param1;
private String param2;
private String param3;
public Builder(String param1){
this.param1 = param1;
}
public Builder param2(){
this.param2 = param2;
return this;
}
public Builder param3(){
this.param3 = param3;
return this;
}
public Product build(){
return new Product(this);
}
}
}
3.使用
public class Use{
public static void main(String[] args){
Product p = new Product.Builder("param1")
.param2("param2")
.param3("param3")
.build();
}
}
总结
- 我们其实使用过很多建造者模式,例如,AlertDialog的Builder。
- 建造者模式是用来创建复杂对象的,如果只是普通的对象,内部逻辑较少或者内部属性不多就没有必要使用建造者模式(以上两个例子就没必要用Builder模式,本人只是用作样例)
优缺点
优点 | 封装性良好,易于解耦,易于扩展,易于精确控制对象的创建 |
---|---|
缺点 | 产生多余的Build对象,如果产品之间的差异性很大,则不适合使用建造者模式,因此其使用范围受到一定的限制 |