ivistang
/
design-patterns
1
0
Fork 0
Code Projects

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

This commit is contained in:
IvisTang 2025-12-09 21:55:32 +08:00
parent 29e554b670
commit cc736d524b
7 changed files with 394 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
go/Makefile
View File

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

9
go/abstract_factory/main.go
View File

@ -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====== 抽象工厂模式结束 ======")
}

120
go/builder/main.go Normal file
View File

@ -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("======= 生成者模式结束 =======")
}

14
python/abstract_factory/main.py
View File

@ -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("====== 抽象工厂模式结束 ======")

121
python/builder/main.py Normal file
View File

@ -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()

18
ts/src/abstract_factory/index.ts
View File

@ -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();
})();

131
ts/src/builder/index.ts Normal file
View File

@ -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("====== 生成者模式结束 ======");
})();