计划模式之制作者模式

计划模式中的制作者模式（Builder Pattern）是一种常用的对象创建型计划模式，它重要用来解决复杂对象的构建标题。以下是对制作者模式的详细先容：
一、定义

制作者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。换句话说，它通过将复杂对象的构建过程分解为一系列简单的步调，并答应用户通过指定这些步调的顺序和参数来创建不同的对象。
二、类图与结构

类图

在制作者模式中，通常包罗以下几个角色：

• 产品角色（Product）：表示被构建的复杂对象，通常包罗多个构成部件。
  
• 抽象制作者（Builder）：定义一个创建产品对象的各个部件的抽象接口。
  
• 具体制作者（ConcreteBuilder）：实现Builder接口，完成复杂产品的各个部件的具体创建方法，并定义一个返回最终产品的接口。
  
• 指挥者（Director）：负责调用制作者对象中的部件构造与装配方法完成复杂对象的创建。它并不涉及具体产品的信息，只是将客户端与制作者解耦。
  

三、实用场景

制作者模式实用于以下场景：

• 对象结构复杂：当必要构建的对象具有复杂的内部结构，包罗多个属性和方法时，使用制作者模式可以简化构建过程。
  
• 构建过程复杂：当对象的构建过程涉及多个步调，且这些步调的顺序和参数大概不同时，制作者模式可以提供一个清晰的构建流程。
  
• 解耦创建和使用：当希望将对象的创建和使用过程分离，使得用户只必要关心对象的最终表示，而不必要关心对象的创建细节时，制作者模式是一个很好的选择。
  

四、优缺点

长处

• 封装性好：将复杂对象的构建过程封装在制作者内部，客户端只必要指定制作的类型和参数，即可得到最终的产品，不必要知道构建过程的细节。
  
• 扩展性好：假如必要增加新的构建类型或修改构建过程，只必要增加或修改制作者类即可，不会对客户端代码产生影响。
  
• 机动性高：通过改变制作者的构建顺序或参数，可以机动地创建不同的产品实例。
  

缺点

• 增加类数量：由于必要创建制作者接口、具体制作者类以及指挥者类等多个类，大概会增加体系的类数量。
  
• 内部修改困难：假如产品的内部结构发生变革，大概必要修改多个制作者类，增加了体系的维护成本。
  

五、示例

在以下示例中，我们将使用制作者模式来计划一个房屋装修体系。我们将定义一个House类作为复杂对象，包罗多个装修部件（如吊顶、涂料、地板、地砖等）。然后，我们定义一个HouseBuilder接口，包罗创建这些部件的抽象方法。接着，我们为每个具体的装修风格（如豪华欧式、轻奢故乡、当代简约）创建具体的制作者类。最后，我们将通过一个Director类来引导制作过程，但它在这个例子中大概不是必需的，因为我们可以直接在制作者类中定义完整的构建逻辑。
不过，为了展示指挥者角色的概念，我们将保留一个Director类，但仅用于说明目的，实际上构建过程可以直接在制作者类中完成。

1. // 房屋类  
2. public class House {  
3.     private String ceiling; // 吊顶  
4.     private String paint;   // 涂料  
5.     private String floor;   // 地板  
6.     private String tiles;   // 地砖  
7.   
8.     // 私有构造函数  
9.     private House() {}  
10.   
11.     // Getter 方法  
12.     public String getCeiling() {  
13.         return ceiling;  
14.     }  
15.   
16.     public String getPaint() {  
17.         return paint;  
18.     }  
19.   
20.     public String getFloor() {  
21.         return floor;  
22.     }  
23.   
24.     public String getTiles() {  
25.         return tiles;  
26.     }  
27.   
28.     // 建造者接口  
29.     public interface HouseBuilder {  
30.         HouseBuilder buildCeiling(String ceiling);  
31.         HouseBuilder buildPaint(String paint);  
32.         HouseBuilder buildFloor(String floor);  
33.         HouseBuilder buildTiles(String tiles);  
34.         House build();  
35.     }  
36.   
37.     // 豪华欧式建造者  ,注意是静态内部类
38.     public static class LuxuryEuropeanBuilder implements HouseBuilder {  
39.         private House house;  
40.   
41.         public LuxuryEuropeanBuilder() {  
42.             this.house = new House();  
43.         }  
44.   
45.         @Override  
46.         public HouseBuilder buildCeiling(String ceiling) {  
47.             house.ceiling = "豪华欧式吊顶: " + ceiling;  
48.             return this;  
49.         }  
50.   
51.         @Override  
52.         public HouseBuilder buildPaint(String paint) {  
53.             house.paint = "豪华欧式涂料: " + paint;  
54.             return this;  
55.         }  
56.   
57.         @Override  
58.         public HouseBuilder buildFloor(String floor) {  
59.             house.floor = "豪华欧式地板: " + floor;  
60.             return this;  
61.         }  
62.   
63.         @Override  
64.         public HouseBuilder buildTiles(String tiles) {  
65.             house.tiles = "豪华欧式地砖: " + tiles;  
66.             return this;  
67.         }  
68.   
69.         @Override  
70.         public House build() {  
71.             return house;  
72.         }  
73.     }  
74.   
75.     // ... 可以为其他风格创建类似的建造者类  
76.   
77.     // 指挥者类（可选，这里主要用于展示概念）  
78.     public static class Director {  
79.         private HouseBuilder builder;  
80.   
81.         public Director(HouseBuilder builder) {  
82.             this.builder = builder;  
83.         }  
84.   
85.         // 这里可以添加方法来指导建造过程，但在这个例子中，我们直接在建造者中完成了所有工作  
86.         public House constructHouse() {  
87.             // 假设这是由指挥者指导的步骤，但在这里我们直接返回建造者的结果  
88.             return builder  
89.                 .buildCeiling("水晶吊灯")  
90.                 .buildPaint("金色镶边涂料")  
91.                 .buildFloor("大理石地板")  
92.                 .buildTiles("马赛克地砖")  
93.                 .build();  
94.         }  
95.     }  
96.   
97.     // 主函数，用于演示  
98.     public static void main(String[] args) {  
99.         HouseBuilder luxuryBuilder = new LuxuryEuropeanBuilder();  
100.         // Director director = new Director(luxuryBuilder); // 如果使用指挥者  
101.   
102.         House house = luxuryBuilder  
103.                 .buildCeiling("水晶吊灯")  
104.                 .buildPaint("金色镶边涂料")  
105.                 .buildFloor("大理石地板")  
106.                 .buildTiles("马赛克地砖")  
107.                 .build();  
108.   
109.         System.out.println("Ceiling: " + house.getCeiling());  
110.         System.out.println("Paint: " + house.getPaint());  
111.         System.out.println("Floor: " + house.getFloor());  
112.         System.out.println("Tiles: " + house.getTiles());  
113.     }  
114. }

复制代码

请注意，在这个例子中，Director类实际上并没有增加太多代价，因为全部的构建逻辑都已经被封装在HouseBuilder接口的实现中了。但在更复杂的应用中，Director类可以用来封装构建过程的顺序和逻辑，特别是当构建过程必要跨越多个制作者时。
六、竣事语

通过以上先容，可以看出制作者模式在构建复杂对象时具有很大的优势，它通过将构建过程与表示分离，进步了代码的封装性和扩展性，同时也降低了客户端与具体产品之间的耦合度。

假如此文对你学习有帮助，记得点赞收藏。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。