golang设计模式之建造者模式

1. 概述

建造者模式将一个复杂的对象与它的表示分离,同样的创造过程可以建造出不停的表示。比如汽车,它包括商标、车轮、颜色、发送机等各种部分。而对于大多数用户而言,无须知道这些部件的装配细节,也几乎不会使用单独某个部件,而是使用一辆完整的汽车,可以通过建造者模式对其进行设计与描述,建造者模式可以将部件和其组装过程分开,一步一步创建一个复杂的对象。

类图:
builder

相关源代码demo在Github上,可供参考!

2. 实现

Go语言实现:

- 定义产品角色

//产品角色
type Car struct {
    Brand string
    Type  string
    Color string
}

func (this *Car) Drive() error {
    fmt.Printf("A %s %s %s car is running on the road!\n", this.Color, this.Type, this.Brand)
    return nil
}
  • 定义建造者角色
//建造者角色
type Builder interface {
    PaintColor(color string) Builder
    AddBrand(brand string) Builder
    SetType(t string) Builder
    Build() Car
}

//具体的建造者
type ConcreteBuilder struct {
    ACar Car
}

func (this *ConcreteBuilder) PaintColor(cor string) Builder {
    this.ACar.Color = cor
    return this
}

func (this *ConcreteBuilder) AddBrand(bnd string) Builder {
    this.ACar.Brand = bnd
    return this
}

func (this *ConcreteBuilder) SetType(t string) Builder {
    this.ACar.Type = t
    return this
}

func (this *ConcreteBuilder) Build() Car {
    return this.ACar
}
  • 定义导演者角色
//导演着角色
type Director struct {
    Builder Builder
}
  • 使用
    dr := Director{&ConcreteBuilder{}}
    adCar := dr.Builder.SetType("SUV").AddBrand("奥迪").PaintColor("white").Build()
    adCar.Drive()

    bwCar := dr.Builder.SetType("sporting").AddBrand("宝马").PaintColor("red").Build()
    bwCar.Drive()

}
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
以下是几种常见的Golang设计模式: 1. 工厂模式(Factory Pattern):用于创建对象的模式,通过定义一个创建对象的接口来实现对象的实例化。 ```go type Shape interface { Draw() } type Circle struct{} func (c *Circle) Draw() { fmt.Println("Drawing a circle") } type Rectangle struct{} func (r *Rectangle) Draw() { fmt.Println("Drawing a rectangle") } type ShapeFactory struct{} func (sf *ShapeFactory) GetShape(shapeType string) Shape { if shapeType == "circle" { return &Circle{} } else if shapeType == "rectangle" { return &Rectangle{} } return nil } func main() { factory := &ShapeFactory{} circle := factory.GetShape("circle") circle.Draw() // 输出:Drawing a circle rectangle := factory.GetShape("rectangle") rectangle.Draw() // 输出:Drawing a rectangle } ``` 2. 单例模式(Singleton Pattern):确保一个类只有一个实例,并提供一个全局访问点。 ```go type Singleton struct{} var instance *Singleton func GetInstance() *Singleton { if instance == nil { instance = &Singleton{} } return instance } func main() { singleton1 := GetInstance() singleton2 := GetInstance() fmt.Println(singleton1 == singleton2) // 输出:true } ``` 3. 观察者模式(Observer Pattern):定义了一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖它的对象都会得到通知并自动更新。 ```go type Subject struct { observers []Observer } func (s *Subject) Attach(observer Observer) { s.observers = append(s.observers, observer) } func (s *Subject) Notify() { for _, observer := range s.observers { observer.Update() } } type Observer interface { Update() } type ConcreteObserver struct{} func (co *ConcreteObserver) Update() { fmt.Println("Observer is updated") } func main() { subject := &Subject{} observer := &ConcreteObserver{} subject.Attach(observer) subject.Notify() // 输出:Observer is updated } ```

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值