技术共享

设计模式之建造者模式

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

设计模式中的建造者模式(Builder Pattern)是一种常用的对象创建型设计模式,它主要用来解决复杂对象的构建问题。以下是对建造者模式的详细介绍:

一、定义

建造者模式将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。换句话说,它通过将复杂对象的构建过程分解为一系列简单的步骤,并允许用户通过指定这些步骤的顺序和参数来创建不同的对象。

二、类图与结构

类图

在建造者模式中,通常包含以下几个角色:

  1. 产品角色(Product):表示被构建的复杂对象,通常包含多个组成部件。
  2. 抽象建造者(Builder):定义一个创建产品对象的各个部件的抽象接口。
  3. 具体建造者(ConcreteBuilder):实现Builder接口,完成复杂产品的各个部件的具体创建方法,并定义一个返回最终产品的接口。
  4. 指挥者(Director):负责调用建造者对象中的部件构造与装配方法完成复杂对象的创建。它并不涉及具体产品的信息,只是将客户端与建造者解耦。

三、适用场景

建造者模式适用于以下场景:

  1. 对象结构复杂:当需要构建的对象具有复杂的内部结构,包含多个属性和方法时,使用建造者模式可以简化构建过程。
  2. 构建过程复杂:当对象的构建过程涉及多个步骤,且这些步骤的顺序和参数可能不同时,建造者模式可以提供一个清晰的构建流程。
  3. 解耦创建和使用:当希望将对象的创建和使用过程分离,使得用户只需要关心对象的最终表示,而不需要关心对象的创建细节时,建造者模式是一个很好的选择。

四、优缺点

优点
  1. 封装性好:将复杂对象的构建过程封装在建造者内部,客户端只需要指定建造的类型和参数,即可得到最终的产品,不需要知道构建过程的细节。
  2. 扩展性好:如果需要增加新的构建类型或修改构建过程,只需要增加或修改建造者类即可,不会对客户端代码产生影响。
  3. 灵活性高:通过改变建造者的构建顺序或参数,可以灵活地创建不同的产品实例。
缺点
  1. 增加类数量:由于需要创建建造者接口、具体建造者类以及指挥者类等多个类,可能会增加系统的类数量。
  2. 内部修改困难:如果产品的内部结构发生变化,可能需要修改多个建造者类,增加了系统的维护成本。

五、示例

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

请注意,在这个例子中,Director类实际上并没有增加太多价值,因为所有的构建逻辑都已经被封装在HouseBuilder接口的实现中了。但在更复杂的应用中,Director类可以用来封装构建过程的顺序和逻辑,特别是当构建过程需要跨越多个建造者时。

六、结束语

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

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