制作者模式（Builder Pattern）

制作者模式（Builder Pattern）

制作者模式是一种 创建型计划模式，它将一个复杂对象的构造与它的表现分离，使得同样的构建过程可以创建差别的表现。

---

原理

• 核心头脑：通过一步步的构建过程来创建复杂对象，而不是直接调用构造函数。
  
• 实用场景：必要创建的对象包罗多个部分，且构造过程相对复杂时。
  
• 到场脚色：
  
  
  
  • Builder（抽象制作者）：界说构建产物各部分的抽象接口。
    
  • ConcreteBuilder（详细制作者）：实现 Builder 接口，构造并装配详细的产物。
    
  • Product（产物）：要创建的复杂对象。
    
  • Director（指挥者）：界说构造步调的次序，将构建过程委托给制作者对象。
    
  
  

---

优点

• 分步构建：允许通太过步调的方式构造对象，构造过程清晰。
  
• 易于扩展：可以机动地创建差别的对象表现。
  
• 解耦构建过程与表现：更易维护和扩展。
  

---

缺点

• 复杂性增长：对于简单对象的创建会显得过于复杂。
  
• 依靠 Director：必要额外引入指挥者脚色。
  

---

示例代码

场景形貌

计划一个 MealBuilder 用于创建差别范例的套餐（如素食套餐和非素食套餐）。每个套餐包罗主食（主菜）、饮料和甜品。

---

1. 界说产物类

1. // 产品类：Meal
2. public class Meal {
3.     private String mainCourse;
4.     private String drink;
5.     private String dessert;
7.     // Setter 方法
8.     public void setMainCourse(String mainCourse) {
9.         this.mainCourse = mainCourse;
10.     }
12.     public void setDrink(String drink) {
13.         this.drink = drink;
14.     }
16.     public void setDessert(String dessert) {
17.         this.dessert = dessert;
18.     }
20.     // 展示方法
21.     public void showItems() {
22.         System.out.println("Meal contains:");
23.         System.out.println("Main Course: " + mainCourse);
24.         System.out.println("Drink: " + drink);
25.         System.out.println("Dessert: " + dessert);
26.     }
27. }

复制代码

---

2. 界说抽象制作者

1. // 抽象建造者
2. public abstract class MealBuilder {
3.     protected Meal meal = new Meal();
5.     public abstract void buildMainCourse();
6.     public abstract void buildDrink();
7.     public abstract void buildDessert();
9.     // 返回构建好的产品
10.     public Meal getMeal() {
11.         return meal;
12.     }
13. }

复制代码

---

3. 界说详细制作者

1. // 具体建造者：素食套餐
2. public class VegMealBuilder extends MealBuilder {
3.     @Override
4.     public void buildMainCourse() {
5.         meal.setMainCourse("Vegetable Curry");
6.     }
8.     @Override
9.     public void buildDrink() {
10.         meal.setDrink("Lemonade");
11.     }
13.     @Override
14.     public void buildDessert() {
15.         meal.setDessert("Fruit Salad");
16.     }
17. }
19. // 具体建造者：非素食套餐
20. public class NonVegMealBuilder extends MealBuilder {
21.     @Override
22.     public void buildMainCourse() {
23.         meal.setMainCourse("Chicken Curry");
24.     }
26.     @Override
27.     public void buildDrink() {
28.         meal.setDrink("Coke");
29.     }
31.     @Override
32.     public void buildDessert() {
33.         meal.setDessert("Ice Cream");
34.     }
35. }

复制代码

---

4. 界说指挥者

1. // 指挥者
2. public class MealDirector {
3.     private MealBuilder builder;
5.     public MealDirector(MealBuilder builder) {
6.         this.builder = builder;
7.     }
9.     public Meal constructMeal() {
10.         builder.buildMainCourse();
11.         builder.buildDrink();
12.         builder.buildDessert();
13.         return builder.getMeal();
14.     }
15. }

复制代码

---

5. 客户端代码

1. public class BuilderPatternExample {
2.     public static void main(String[] args) {
3.         // 构建素食套餐
4.         MealBuilder vegMealBuilder = new VegMealBuilder();
5.         MealDirector vegDirector = new MealDirector(vegMealBuilder);
6.         Meal vegMeal = vegDirector.constructMeal();
7.         System.out.println("Veg Meal:");
8.         vegMeal.showItems();
10.         System.out.println("----------------------");
12.         // 构建非素食套餐
13.         MealBuilder nonVegMealBuilder = new NonVegMealBuilder();
14.         MealDirector nonVegDirector = new MealDirector(nonVegMealBuilder);
15.         Meal nonVegMeal = nonVegDirector.constructMeal();
16.         System.out.println("Non-Veg Meal:");
17.         nonVegMeal.showItems();
18.     }
19. }

复制代码

---

输出结果

1. Veg Meal:
2. Meal contains:
3. Main Course: Vegetable Curry
4. Drink: Lemonade
5. Dessert: Fruit Salad
6. ----------------------
7. Non-Veg Meal:
8. Meal contains:
9. Main Course: Chicken Curry
10. Drink: Coke
11. Dessert: Ice Cream

复制代码

---

UML 类图

1.       +----------------+
2.       |   Meal         |
3.       +----------------+
4.       | - mainCourse   |
5.       | - drink        |
6.       | - dessert      |
7.       +----------------+
8.       | + setXXX()     |
9.       | + showItems()  |
10.       +----------------+
11.                ^
12.                |
13.       +----------------+
14.       | MealBuilder    |
15.       +----------------+
16.       | + buildXXX()   |
17.       | + getMeal()    |
18.       +----------------+
19.          /         \
20. +---------------+   +-----------------+
21. | VegMealBuilder|   | NonVegMealBuilder|
22. +---------------+   +-----------------+
23.                ^
24.                |
25.       +----------------+
26.       | MealDirector   |
27.       +----------------+
28.       | - builder      |
29.       | + constructMeal|
30.       +----------------+

复制代码

---

实用场景

• 复杂对象的创建：对象包罗多个构成部分，且构建次序不可或缺。
  
• 构造过程稳固，表现多样：同一构造流程可用于创建差别表现的对象。
  
• 代码清晰：通太过离构造过程简化了客户端逻辑。
  

---

小结

• 制作者模式得当构建复杂对象并关注构建过程的场景。
  
• 它将产物的创建与表现分离，进步了机动性和扩展性。
  
• 缺点：当产物构造步调或范例较少时，使用该模式大概显得冗余。