更新生成者模式示例，添加木屋和砖房建造者实现，重构相关代码并增强可读性

go/Makefile

@@ -1,4 +1,4 @@
-BUILDDIR := build
+BUILDDIR := bin
 DIRS := $(shell ls -d */)
 
 ifndef VERBOSE

go/abstract_factory/main.go

@@ -3,7 +3,7 @@ package main
 import "fmt"
 
 /* 实例
-今天伟哥约自己在富士康工作的老乡出来喝酒，没想到老乡最近一直在加班。听说接了个大活，要同时为小米公司和苹果公司代工他们的笔记本电脑和手机生产业务。
+今天汤宝宝约自己在富士康工作的老乡出来喝酒，没想到老乡最近一直在加班。听说接了个大活，要同时为小米公司和苹果公司代工他们的笔记本电脑和手机生产业务。
 */
 
 // 抽象产品：手机
@@ -114,6 +114,7 @@ func newMiFactory() Factory {
 	return &MiFactory{name: "小米工厂"}
 }
 
+// 客户端代码
 func client(factory Factory) {
 	phone := factory.CreatePhone()
 	laptop := factory.CreateLaptop()
@@ -132,7 +133,7 @@ func main() {
 
 	// 选择苹果工厂
 	factory = newAppleFactory()
-	fmt.Printf("伟哥选择了%s生产产品:\n", factory.(*AppleFactory).name)
+	fmt.Printf("汤宝宝选择了%s生产产品:\n", factory.(*AppleFactory).name)
 	client(factory)
 
 	fmt.Println()
@@ -141,7 +142,7 @@ func main() {
 
 	// 选择小米工厂
 	factory = newMiFactory()
-	fmt.Printf("伟哥选择了%s生产产品:\n", factory.(*MiFactory).name)
+	fmt.Printf("汤宝宝选择了%s生产产品:\n", factory.(*MiFactory).name)
 	client(factory)
-	fmt.Println("====== 抽象工厂模式结束 ======")
+	fmt.Println("\n====== 抽象工厂模式结束 ======")
 }

go/builder/main.go

@@ -0,0 +1,120 @@
+package main
+
+import "fmt"
+
+/* 实例
+汤宝宝想要建造一栋属于自己的房子，于是找来了著名的建筑设计
+公司——生成者模式公司（Builder Pattern Inc.）帮忙设计和建造房子。
+*/
+
+// 产品：房子
+type House struct {
+	Foundation string // 地基
+	Structure  string // 结构
+	Roof       string // 屋顶
+}
+
+// 建造者接口
+type HouseBuilder interface {
+	buildFoundation()
+	buildStructure()
+	buildRoof()
+	getHouse() House
+}
+
+// 具体建造者：木屋建造者
+type WoodenHouseBuilder struct {
+	house House
+}
+
+func (b *WoodenHouseBuilder) buildFoundation() {
+	b.house.Foundation = "木桩地基"
+	fmt.Println("  建造木桩地基")
+}
+
+func (b *WoodenHouseBuilder) buildStructure() {
+	b.house.Structure = "木结构"
+	fmt.Println("  建造木结构")
+}
+
+func (b *WoodenHouseBuilder) buildRoof() {
+	b.house.Roof = "木屋顶"
+	fmt.Println("  建造木屋顶")
+}
+
+func (b *WoodenHouseBuilder) getHouse() House {
+	return b.house
+}
+
+// 具体建造者：砖房建造者
+type BrickHouseBuilder struct {
+	house House
+}
+
+func (b *BrickHouseBuilder) buildFoundation() {
+	b.house.Foundation = "混凝土地基"
+	fmt.Println("  建造混凝土地基")
+}
+
+func (b *BrickHouseBuilder) buildStructure() {
+	b.house.Structure = "砖结构"
+	fmt.Println("  建造砖结构")
+}
+
+func (b *BrickHouseBuilder) buildRoof() {
+	b.house.Roof = "瓦屋顶"
+	fmt.Println("  建造瓦屋顶")
+}
+
+func (b *BrickHouseBuilder) getHouse() House {
+	return b.house
+}
+
+// 指挥者
+type Director struct {
+	builder HouseBuilder
+	house   House
+}
+
+// 重置房子
+func (d *Director) reset() {
+	d.house = House{}
+}
+
+func (d *Director) setBuilder(b HouseBuilder) {
+	d.builder = b
+}
+
+func (d *Director) constructHouse() {
+	d.reset()
+	d.builder.buildFoundation()
+	d.builder.buildStructure()
+	d.builder.buildRoof()
+	d.house = d.builder.getHouse()
+}
+
+func main() {
+	var builder HouseBuilder
+	var director Director
+	var house House
+
+	fmt.Println("========= 生成者模式 =========")
+	// 使用木屋建造者
+	builder = &WoodenHouseBuilder{}
+	director.setBuilder(builder)
+	fmt.Println("建造木屋：")
+	director.constructHouse()
+	house = director.house
+	fmt.Printf("木屋建造完成：%s %s %s\n\n", house.Foundation, house.Structure, house.Roof)
+
+	// 使用砖房建造者
+	builder = &BrickHouseBuilder{}
+	director.setBuilder(builder)
+	fmt.Println("建造砖房：")
+	director.constructHouse()
+	house = director.house
+	fmt.Printf("砖房建造完成：%s %s %s\n\n", house.Foundation, house.Structure, house.Roof)
+
+	fmt.Println("======= 生成者模式结束 =======")
+
+}

python/abstract_factory/main.py

@@ -1,6 +1,7 @@
 """
 实例
-今天伟哥约自己在富士康工作的老乡出来喝酒，没想到老乡最近一直在加班。听说接了个大活，要同时为小米公司和苹果公司代工他们的笔记本电脑和手机生产业务。
+今天汤宝宝约自己在富士康工作的老乡出来喝酒，没想到老乡最近一直在加班。
+听说接了个大活，要同时为小米公司和苹果公司代工他们的笔记本电脑和手机生产业务。
 """
 
 from abc import ABC, abstractmethod
@@ -98,7 +99,7 @@ class XiaomiFactory(AbstractFactory):
     def createLaptop(self):
         return MiLaptop()
 
-
+# 客户端代码
 def client(factory: AbstractFactory):
     phone = factory.createPhone()
     laptop = factory.createLaptop()
@@ -111,17 +112,16 @@ def client(factory: AbstractFactory):
 def main():
     print("======== 抽象工厂模式 ========")
 
-    # 伟哥先去苹果工厂生产产品
+    # 先去苹果工厂生产产品
-    print("伟哥选择了苹果工厂生产产品:")
     factory = AppleFactory()
-    print(f"伟哥选择了{factory.name}生产产品:")
+    print(f"汤宝宝选择了{factory.name}生产产品:")
     client(factory)
 
     print("\n切换工厂生产其他品牌的产品...\n")
 
-    # 然后伟哥去小米工厂生产产品
+    # 然后去小米工厂生产产品
     factory = XiaomiFactory()
-    print(f"伟哥选择了{factory.name}生产产品:")
+    print(f"汤宝宝选择了{factory.name}生产产品:")
     client(factory)
 
     print("====== 抽象工厂模式结束 ======")

python/builder/main.py

@@ -0,0 +1,121 @@
+"""
+实例
+汤宝宝想要建造一栋属于自己的房子，于是找来了著名的建筑设计
+公司——生成者模式公司（Builder Pattern Inc.）帮忙设计和建造房子。
+"""
+
+from abc import ABC, abstractmethod
+
+
+# 产品： 房子
+class House(ABC):
+    foundation: str
+    structure: str
+    roof: str
+
+
+# 抽象建造者： 房屋建造者
+class HouseBuilder(ABC):
+    @abstractmethod
+    def buildFoundation(self) -> None:
+        pass
+
+    @abstractmethod
+    def buildStructure(self) -> None:
+        pass
+
+    @abstractmethod
+    def buildRoof(self) -> None:
+        pass
+
+    @abstractmethod
+    def getHouse(self) -> House:
+        pass
+
+
+# 具体建造者： 木屋建造者
+class WoodenHouseBuilder(HouseBuilder):
+    def __init__(self):
+        self.house = House()
+
+    def buildFoundation(self) -> None:
+        self.house.foundation = "木桩地基"
+        print("  建造木桩地基")
+
+    def buildStructure(self) -> None:
+        self.house.structure = "木结构"
+        print("  建造木结构")
+
+    def buildRoof(self) -> None:
+        self.house.roof = "木屋顶"
+        print("  建造木屋顶")
+
+    def getHouse(self) -> House:
+        return self.house
+
+
+# 具体建造者： 砖房建造者
+class BrickHouseBuilder(HouseBuilder):
+    def __init__(self):
+        self.house = House()
+
+    def buildFoundation(self) -> None:
+        self.house.foundation = "混凝土地基"
+        print("  建造混凝土地基")
+
+    def buildStructure(self) -> None:
+        self.house.structure = "砖结构"
+        print("  建造砖结构")
+
+    def buildRoof(self) -> None:
+        self.house.roof = "瓦屋顶"
+        print("  建造瓦屋顶")
+
+    def getHouse(self) -> House:
+        return self.house
+
+
+# 指挥者
+class Director:
+    builder: HouseBuilder
+    house: House
+
+    def reset(self) -> None:
+        if hasattr(self, "house"):
+            del self.house
+
+    def setBuilder(self, builder: HouseBuilder) -> None:
+        self.builder = builder
+
+    def constructHouse(self):
+        self.reset()
+        self.builder.buildFoundation()
+        self.builder.buildStructure()
+        self.builder.buildRoof()
+        self.house = self.builder.getHouse()
+
+
+def main():
+    print("======== 生成者模式 ========")
+
+    director = Director()
+
+    print("建造木屋:")
+    builder = WoodenHouseBuilder()
+    director.setBuilder(builder)
+    director.constructHouse()
+    house = director.house
+    print(f"木屋建造完成: {house.foundation}, {house.structure}, {house.roof}\n")
+
+    print("建造砖房:")
+    builder = BrickHouseBuilder()
+    director.setBuilder(builder)
+    director.constructHouse()
+    house = director.house
+    print(f"砖房建造完成: {house.foundation}, {house.structure}, {house.roof}\n")
+
+    print("====== 生成者模式结束 ======")
+
+
+if __name__ == "__main__":
+    main()

ts/src/abstract_factory/index.ts

@@ -1,6 +1,7 @@
 /*
 实例
-今天伟哥约自己在富士康工作的老乡出来喝酒，没想到老乡最近一直在加班。听说接了个大活，要同时为小米公司和苹果公司代工他们的笔记本电脑和手机生产业务。
+今天汤宝宝约自己在富士康工作的老乡出来喝酒，没想到老乡最近一直在加班。
+听说接了个大活，要同时为小米公司和苹果公司代工他们的笔记本电脑和手机生产业务。
 */
 
 // 抽象产品 - 手机
@@ -76,6 +77,7 @@ class XiaomiFactory extends AbstractFactory {
   }
 }
 
+// 客户端代码
 const client = (factory: AbstractFactory) => {
   const phone = factory.createPhone();
   const laptop = factory.createLaptop();
@@ -85,22 +87,20 @@ const client = (factory: AbstractFactory) => {
   laptop.setOS();
 };
 
-function main() {
+(function () {
   console.log("======== 抽象工厂模式 ========");
 
-  // 伟哥先去苹果工厂生产产品
+  // 先去苹果工厂生产产品
   let factory: AbstractFactory = new AppleFactory();
-  console.log(`伟哥选择了${factory.name}生产产品:`);
+  console.log(`汤宝宝选择了${factory.name}生产产品:`);
   client(factory);
 
   console.log("\n切换工厂生产其他品牌的产品...\n");
 
-  // 伟哥又去小米工厂生产产品
+  // 又去小米工厂生产产品
   factory = new XiaomiFactory();
-  console.log(`伟哥选择了${factory.name}生产产品:`);
+  console.log(`汤宝宝选择了${factory.name}生产产品:`);
   client(factory);
 
   console.log("====== 抽象工厂模式结束 ======");
-}
+})();
-
-main();

ts/src/builder/index.ts

@@ -0,0 +1,131 @@
+/*
+实例
+今天汤宝宝约自己在富士康工作的老乡出来喝酒，没想到老乡最近一直在加班。
+听说接了个大活，要同时为小米公司和苹果公司代工他们的笔记本电脑和手机生产业务。
+*/
+
+// 产品： 房子
+class House {
+  foundation: string | undefined;
+  structure: string | undefined;
+  roof: string | undefined;
+}
+
+// 抽象建造者： 房屋建造者
+abstract class HouseBuilder {
+  abstract house: House;
+  abstract buildFoundation(): void;
+  abstract buildStructure(): void;
+  abstract buildRoof(): void;
+  abstract getHouse(): House;
+}
+
+class WoodenHouseBuilder extends HouseBuilder {
+  house: House;
+  constructor() {
+    super();
+    this.house = new House();
+  }
+
+  buildFoundation(): void {
+    this.house.foundation = "木桩地基";
+    console.log("  建造木桩地基");
+  }
+
+  buildStructure(): void {
+    this.house.structure = "木结构";
+    console.log("  建造木结构");
+  }
+
+  buildRoof(): void {
+    this.house.roof = "木屋顶";
+    console.log("  建造木屋顶");
+  }
+
+  getHouse(): House {
+    return this.house;
+  }
+}
+class BrickHouseBuilder extends HouseBuilder {
+  house: House;
+  constructor() {
+    super();
+    this.house = new House();
+  }
+
+  buildFoundation(): void {
+    this.house.foundation = "混凝土地基";
+    console.log("  建造混凝土地基");
+  }
+  buildStructure(): void {
+    this.house.structure = "砖结构";
+    console.log("  建造砖结构");
+  }
+  buildRoof(): void {
+    this.house.roof = "瓦屋顶";
+    console.log("  建造瓦屋顶");
+  }
+  getHouse(): House {
+    return this.house;
+  }
+}
+
+// 指挥者
+class Director {
+  private builder: HouseBuilder;
+  public house: House;
+
+  constructor() {
+    this.builder = {} as HouseBuilder;
+    this.house = new House();
+  }
+
+  public reset(): void {
+    this.house = new House();
+  }
+
+  public setBuilder(builder: HouseBuilder): void {
+    this.builder = builder;
+  }
+
+  public constructHouse(): void {
+    this.builder.buildFoundation();
+    this.builder.buildStructure();
+    this.builder.buildRoof();
+    this.house = this.builder.getHouse();
+  }
+}
+
+(function () {
+  console.log("======== 建造者模式 ========");
+
+  const director = new Director();
+
+  console.log("建造木屋:");
+  let builder = new WoodenHouseBuilder();
+  director.setBuilder(builder);
+  director.constructHouse();
+  let house = director.house;
+  console.log(
+    `木屋建造完成:`,
+    house.foundation,
+    house.structure,
+    house.roof,
+    "\n"
+  );
+
+  console.log("建造砖房:");
+  builder = new BrickHouseBuilder();
+  director.setBuilder(builder);
+  director.constructHouse();
+  house = director.house;
+  console.log(
+    `砖房建造完成:`,
+    house.foundation,
+    house.structure,
+    house.roof,
+    "\n"
+  );
+
+  console.log("====== 生成者模式结束 ======");
+})();