- 建造者模式:他不直接生成想要的对象,而是让客户端利用所有必要的参数调用构造器(或静态工厂),得到一个builder对象,然后客户端在builde对象上调用类似setter的方法,来设置每个相关的可选参数, 最后,客户端调用无参的builder方法来生成通常是不可变的对象。
**
* @author 犀角
* @date 2021/6/7 22:47
* @description 建造者模式:他不直接生成想要的对象,而是让客户端利用所有必要的参数调用构造器(或静态工厂),
* 得到一个builder对象,然后客户端在builder对象上调用类似setter的方法,来设置每个相关的可选参数,
* 最后,客户端调用无参的builder方法来生成通常是不可变的对象。
*/
public class NutrionFacts {
private final int servingSize;
private final int servings;
private final int calorages;
private final int fat;
private final int sodium;
private final int carbohydrate;
private NutrionFacts(Builder builder) {
servings = builder.servings;
servingSize = builder.servingSize;
calorages = builder.calorages;
fat = builder.fat;
sodium = builder.sodium;
carbohydrate = builder.carbohydrate;
}
public static class Builder {
//必须参数
private final int servingSize;
private final int servings;
//可选参数
private int calorages;
private int fat;
private int sodium;
private int carbohydrate;
public Builder(int servingSize, int servings) {
this.servingSize = servingSize;
this.servings = servings;
}
public Builder calorages(int val) {
calorages = val;
return this;
}
public Builder fat(int val) {
fat = val;
return this;
}
public Builder sodium(int val) {
sodium = val;
return this;
}
public Builder carbohydrate(int val) {
carbohydrate = val;
return this;
}
public NutrionFacts builder() {
return new NutrionFacts(this);
}
}
public static void main(String[] args) {
//流式API
NutrionFacts facts = new NutrionFacts.Builder(29, 9).calorages(122).carbohydrate(45).fat(243).sodium(452).builder();
}
}
Builder模式适用于类层次结构,抽象类有抽象的builder,具体类有具体的builder。用类层次根部的一个抽象类表示格式各样的披萨
package baseDemo;
import java.util.EnumSet;
import java.util.Objects;
import java.util.Set;
/**
* @author 犀角
* @date 2021/6/7 23:13
* @description Builder模式适用于类层次结构,抽象类有抽象的builder,具体类有具体的builder。
* <p>
* 例如:用类层次根部的一个抽象类表示格式各样的披萨
*/
public class Pizza {
public enum Topping {HAM, MUSHROOM, ONION, PEPPER, SAUSAGE}
final Set<Topping> toppings;
abstract static class Builder<T extends Builder<T>> {
//创建具有指定元素类型的空枚举集。
EnumSet<Topping> toppings = EnumSet.noneOf(Topping.class);
public T addTopping(Topping topping) {
toppings.add(Objects.requireNonNull(topping));
return self();
}
abstract Pizza build();
//子类必须重写这个方法来返回this对象
protected abstract T self();
}
Pizza(Builder<?> builder) {
toppings = builder.toppings.clone();
}
}
package baseDemo;
import java.util.Objects;
/**
* @author 犀角
* @date 2021/6/7 23:22
* @description
*/
public class NyPizza extends Pizza {
public NyPizza(Builder builder) {
super(builder);
size = builder.size;
}
public enum Size {SMALL, MEDIUM, LARGE}
private final Size size;
public static class Builder extends Pizza.Builder<Builder> {
private final Size size;
public Builder(Size size) {
this.size = Objects.requireNonNull(size);
}
@Override
public NyPizza build() {
return new NyPizza(this);
}
@Override
protected Builder self() {
return this;
}
}
}