使用场景
当一个类的构造函数参数超过4个,且不是所有的参数都是必选项,可以考虑使用构造函数。
优点
- 隔离了构建的步骤和具体实现,为产品的具体实现提供了灵活度
- 封装和抽象了每个步骤的实现,实现了依赖倒转原则
- 封装了具体的步骤,减少了代码荣誉
// Builder在java中的简化使用
public class Product{
private final String a;//必须
private final int b;//可选
private Computer(Builder builder){
this.a=builder.a;
this.b=builder.b;
}
public static class Builder{
private String a;//必须
private int b;//可选
public Builder(String a){
this.a=a;
}
public Builder setB(intb) {
this.b= b;
return this;
}
public Computer build(){
return new Computer(this);
}
}
//省略getter方法
}
// 调用方式
Product product = Product.Builder(a).setB().xxxxx.build();
传统使用方式
- Product: 最终要生成的对象
- Builder: 构建者的抽象基类(有时会使用接口代替)。其定义了构建Product的抽象步骤,其实体类需要实现这些步骤。其会包含一个用来返回最终产品的方法
Product getProduct()
。 - ConcreteBuilder: Builder的实现类。
- Director: 决定如何构建最终产品的算法. 其会包含一个负责组装的方法
void Construct(Builder builder)
, 在这个方法中通过调用builder的方法,就可以设置builder,等设置完成后,就可以通过builder的getProduct()
方法获得最终的产品。
Product {
private int a;
private int b;
private int c;
public Product(int a) {
this.a = a;
}
public void setB(int B) {
this.b = b;
}
public void setC(int c) {
this.c = c;
}
}
// 抽象构造类,方便构造不同的产品
ProductBuilder{
public abstract void setB();
public abstract void setC();
public abstract Product getProduct();
}
public class firstProductBuilder extends ProductBuilder {
private Product product;
public firstProductBuilder (int a) {
product= new Product (a);
}
@Override
public void setB() {
computer.setB(2);
}
@Override
public void setC(int c) {
computer.setB(c);
}
}
public class ProductDirector {
public void makeFirstProduct(ProductBuilder builder){
builder.setB();
builder.setC(1);
}
}
// 使用方式
ProductDirector director=new ProductDirector ();//1
ProductBuilder builder=new FirstProductBuilder(1);//2
director.makeFirstProduct(builder);//3
Product firstProduct=builder.getProductr();//4
简化模式其实就是省略了director这个角色,将构建完全交给使用方
同时将对应的Builder放入到Product中,并采用链式调用。
学习笔记