golang 建造者模式

一、定义

在软件开发过程中有时需要创建一个复杂的对象,这个复杂对象通常由多个子部件按一定的步骤组合而成。产品都是由多个部件构成的,各个部件可以灵活选择,但其创建步骤都大同小异。将一个复杂对象的构造与它的表示分离,使同样的构建过程可以创建不同的表示,这样的设计模式被称为建造者模式。它是将一个复杂的对象分解为多个简单的对象,然后一步一步构建而成。它将变与不变相分离,即产品的组成部分是不变的,但每一部分是可以灵活选择的。
在这里插入图片描述

二、理解

其实学习每一个设计模式都不难,难的是在于找到它的应用之处,以及各种模式间的区别在什么地方,不然就会陷入一个困境 ,学完一个,忘记一个,甚至搞混掉。
建造者模式也是生成对象的模式,我们和工厂方法做对比可以发现,去除掉非核心的指挥者后,从类图关系上几乎无差异:建造者对应具体工厂,不同工厂返回不同的产品。那么差别在哪呢?从类图中也能够看到,抽象建造者中自己实现了getResult方法,而具体建造者只需关注生产各个组件即可。也就是建造者模式注重零部件的组装过程(getResult),而工厂方法模式更注重零部件的创建过程。

三、代码示例

模拟顾客(client)向销售员(指挥者)购买电脑(产品)的过程。其中脑PC由主机mainframes、显示器screen、鼠标Mouse组成,电脑具体厂家有两个。代码如下:

//建造者模式,电脑由
//包括:产品:电脑PC由主机mainframes、显示器screen、鼠标Mouse组成
//抽象建造者:电脑厂
//具体建造者:具体电脑厂家
//指挥者:导购
func main() {
	//两个厂家
	lenove := new(Lenove)
	asus := new(Asus)

	//销售
	saleMan := &SaleMan{asus}
	saleMan2 := &SaleMan{lenove}

	fmt.Printf("info:%#v\n",saleMan.SalePC())
	fmt.Printf("info:%#v",saleMan2.SalePC())
}

type SaleMan struct {
	Factory IPCFactory//哪个商家的
}

func (saleMan *SaleMan) SalePC() *PC {
	return saleMan.Factory.ProduceComputer()
}

type PC struct {
	Mainframes string
	Screen string
	Mouse string
}
//着重的是在于生产不同的组件,然后组装在一起。这是和工厂模式的区分。如果不加入这些生产部分组件的 方法,和工厂模式无异
//在java中有抽象类,而golang中没有,因此,生产总
type IPCFactory interface {
	ProduceComputer()*PC
	ProduceMainframes()string
	ProduceScreen()string
	ProduceMouse()string
}

//联想
type Lenove struct {
}

func (factory *Lenove) ProduceComputer() *PC {
	pc := new(PC)
	pc.Mainframes = factory.ProduceMainframes()
	pc.Mouse = factory.ProduceMouse()
	pc.Screen = factory.ProduceScreen()
	return pc
}
func (factory *Lenove) ProduceMainframes() string {
	return "联想的主机"
}
func (factory *Lenove) ProduceScreen() string {
	return "联想的屏幕"
}
func (factory *Lenove) ProduceMouse() string {
	return "联想的鼠标"
}
//华硕
type Asus struct {
}
func (factory *Asus) ProduceComputer() *PC {
	pc := new(PC)
	pc.Mainframes = factory.ProduceMainframes()
	pc.Mouse = factory.ProduceMouse()
	pc.Screen = factory.ProduceScreen()
	return pc
}
func (factory *Asus) ProduceMainframes() string {
	return "华硕的主机"
}
func (factory *Asus) ProduceScreen() string {
	return "华硕的屏幕"
}
func (factory *Asus) ProduceMouse() string {
	return "华硕的鼠标"
}

在这里插入图片描述

  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 工厂模式是一种创建设计模式,它提供了一种创建对象的最佳方式,而无需暴露对象创建的逻辑。在 Golang 中,可以使用工厂函数来实现工厂模式。工厂函数是一个返回接口类型的函数,该接口表示所需对象的抽象类型。具体的对象类型由工厂函数内部的逻辑决定。以下是一个使用 Golang 实现工厂模式的示例代码: ``` package main import "fmt" type Product interface { GetName() string } type ConcreteProductA struct{} func (p *ConcreteProductA) GetName() string { return "Product A" } type ConcreteProductB struct{} func (p *ConcreteProductB) GetName() string { return "Product B" } func CreateProduct(productType string) Product { switch productType { case "A": return &ConcreteProductA{} case "B": return &ConcreteProductB{} default: return nil } } func main() { productA := CreateProduct("A") fmt.Println(productA.GetName()) productB := CreateProduct("B") fmt.Println(productB.GetName()) } ``` 在上面的示例代码中,我们定义了一个 `Product` 接口和两个具体的产品类型 `ConcreteProductA` 和 `ConcreteProductB`。我们还定义了一个 `CreateProduct` 工厂函数,该函数根据传入的参数返回不同的产品类型。在 `main` 函数中,我们使用 `CreateProduct` 函数创建了两个不同的产品,并调用了它们的 `GetName` 方法。 这就是使用 Golang 实现工厂模式的基本方法。 ### 回答2: 工厂模式是一种创建对象的设计模式,其目的是将对象的创建与使用分离,以便在需要时根据不同的条件和参数创建不同的对象。使用Golang编写工厂模式可以按照以下步骤进行: 1. 首先,创建一个接口,定义所需对象的方法和属性。 ```go type Product interface { GetName() string SetName(name string) GetPrice() float64 } ``` 2. 然后,创建多个结构体类型,实现该接口。每个结构体代表一个具体的产品。 ```go type TV struct { name string price float64 } func (t *TV) GetName() string { return t.name } func (t *TV) SetName(name string) { t.name = name } func (t *TV) GetPrice() float64 { return t.price } type Computer struct { name string price float64 } func (c *Computer) GetName() string { return c.name } func (c *Computer) SetName(name string) { c.name = name } func (c *Computer) GetPrice() float64 { return c.price } ``` 3. 创建一个工厂函数,根据传入的参数返回对应的对象实例。 ```go func CreateProduct(productType string) Product { switch productType { case "TV": return &TV{} case "Computer": return &Computer{} default: return nil } } ``` 4. 在主函数中调用工厂函数创建具体的产品对象。 ```go func main() { tv := CreateProduct("TV") tv.SetName("Samsung TV") tv.GetPrice() computer := CreateProduct("Computer") computer.SetName("Lenovo Computer") computer.GetPrice() } ``` 通过以上步骤,我们可以使用Golang编写一个简单的工厂模式,根据需要创建不同类型的产品对象。这种模式可以将创建对象的细节封装起来,并提供统一的接口来使用不同的产品。 ### 回答3: 工厂模式是一种创建对象的设计模式,通过定义一个统一的接口和工厂方法,来创建不同类型的对象。在golang中,可以使用结构体和接口的方式实现工厂模式。 首先,我们定义一个接口,用于表示要创建的对象: ```go type Product interface { Name() string Price() float64 } ``` 然后,我们创建多个结构体类型实现该接口,每个结构体类型表示一种具体的产品: ```go type ProductA struct {} func (a *ProductA) Name() string { return "ProductA" } func (a *ProductA) Price() float64 { return 10.0 } type ProductB struct {} func (b *ProductB) Name() string { return "ProductB" } func (b *ProductB) Price() float64 { return 20.0 } ``` 接下来,我们定义一个工厂结构体,用于创建不同类型的产品对象: ```go type ProductFactory struct {} func (f *ProductFactory) CreateProduct(productType string) Product { switch productType { case "A": return &ProductA{} case "B": return &ProductB{} default: return nil } } ``` 最后,我们可以通过调用工厂的CreateProduct方法来创建不同类型的产品对象: ```go func main() { factory := &ProductFactory{} productA := factory.CreateProduct("A") fmt.Println(productA.Name(), productA.Price()) productB := factory.CreateProduct("B") fmt.Println(productB.Name(), productB.Price()) } ``` 以上就是使用golang写工厂模式的简单示例。使用工厂模式可以封装对象的创建逻辑,使得客户端程序与具体产品的实现解耦。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值