Modo Builder
O modo construtor é um tipo de modo de criação. Podemos usar vários objetos simples para construir gradualmente objetos complexos, e a classe Builder será gradualmente construída no objeto final.A classe Builder é independente de outros objetos.
Quando o modo construtor será usado? Normalmente, quando alguns materiais básicos não mudam e sua combinação muda frequentemente, isso pode ser considerado uma vantagem ou uma desvantagem. O modo construtor satisfaz o princípio de responsabilidade única e capacidade de reutilização, e os construtores são relativamente independentes. No entanto, à medida que os materiais e as combinações aumentam gradualmente, a manutenção será relativamente problemática.
Na vida diária, o estilo de decoração da nova casa, a refeição do hambúrguer KFC McDonald’s ou a refeição do chá da tarde Starbucks, os materiais nestes exemplos são geralmente fixos e diferentes conjuntos de refeições podem ser produzidos por meio de combinação.
No pacote de chá da tarde Starbucks estão incluídos café e bolo, e eles têm diferentes tipos, embalagens e preços.Podemos realizar o modo builder combinando diferentes tipos de café e bolos.
O pacote Starbucks implementa o modo builder:
//套餐接口
public interface Item {
String name();
Package packaging();
float price();
}
//包装接口
public interface Package {
String packaging();
}
Em seguida, definimos a embalagem de diferentes itens
//瓶子
public class Bottle implements Package {
@Override
public String packaging() {
return "Bottle";
}
}
//盒子
public class Wrapper implements Package {
@Override
public String packaging() {
return "Wrapper";
}
}
Depois de definir a interface do pacote, precisamos definir o item
//拿铁咖啡
public class Latte extends Coffee {
@Override
public String name() {
return "Latte";
}
@Override
public float price() {
return 32;
}
}
//卡布奇诺
public class Cappuccino extends Coffee {
@Override
public String name() {
return "Cappuccino";
}
@Override
public float price() {
return 36;
}
}
//汤圆蛋糕
public class Socake extends Cake {
@Override
public String name() {
return "Socake";
}
@Override
public float price() {
return 35;
}
}
//草莓蛋糕
public class StrawberryCake extends Cake {
@Override
public String name() {
return "StrawberryCake";
}
@Override
public float price() {
return 36;
}
}
Essas mercadorias podem ser compostas de diferentes pacotes e, em seguida, criar pacotes
public class Order {
//订单存放coffee 和 cake
private List<Item> itemList = new ArrayList<>();
//商品添加到套餐中
public void add(Item item){
itemList.add(item);
}
//获取总价
public float getTotal(){
float total = 0;
for (Item i: itemList) {
total += i.price();
}
return total;
}
//打印订单
public void print(){
for (Item item : itemList) {
System.out.print("Item : "+item.name());
System.out.print(", Packing : "+item.packaging().packaging());
System.out.println(", Price : "+item.price());
}
}
}
Crie a classe Builder
//创建套餐Builder
public class OrderBuilder {
//汤圆蛋糕配卡布奇诺套餐
public Order SoCake_Cappuccino(){
Order order = new Order();
order.add(new Cappuccino());
order.add(new Socake());
return order;
}
//拿铁配草莓蛋糕套餐
public Order Strawberry_Latte(){
Order order = new Order();
order.add(new StrawberryCake());
order.add(new Latte());
return order;
}
//汤圆蛋糕配拿铁套餐
public Order SoCake_Latte(){
Order order = new Order();
order.add(new Socake());
order.add(new Latte());
return order;
}
}
//根据多种物料可以进行多种组合
Finalmente, crie uma classe de teste para testar
//测试类测试
public class BuilderPatternTest{
public static void main(String[] args) {
OrderBuilder orderBuilder = new OrderBuilder();
Order Socake_Latte = orderBuilder.SoCake_Latte();
Socake_Latte.print();
System.out.println("Total Price:" + Socake_Latte.getTotal());
}
}
//输出结果
//Item : Socake, Packing : Wrapper, Price : 35.0
//Item : Latte, Packing : Bottle, Price : 32.0
//Total Price:67.0
vantagem:
1. Bom encapsulamento, o modo construtor dispensa o cliente de conhecer o processo de construção e os componentes do produto, o que está de acordo com a lei de Dimit no princípio do projeto.
2. O construtor é fácil de expandir e também relativamente independente.
Resumo : O chamado modo builder serve para criar os objetos complexos de que precisamos por meio da classe Builder.Estes detalhes são ocultados por nós. Se a criação interna de um objeto for muito complicada, você pode considerar o uso do modo builder. Pelo contrário, se for relativamente simples, você não precisa usar o modo builder. Não endureça o modo de design para o por causa do modo de design, o que pode ser contraproducente.