golang工厂方法模式

这篇博客探讨了如何在Go语言中实现工厂方法模式,由于Go不支持继承,所以采用匿名组合来替代,通过示例代码`factorymethod.go`和测试文件`factorymethod_test.go`阐述了具体实现方式。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

工厂方法模式使用子类的方式延迟生成对象到子类中实现。

Go中不存在继承 所以使用匿名组合来实现

factorymethod.go
package factorymethod

//Operator 是被封装的实际类接口
type Operator interface {
    SetA(int)
    SetB(int)
    Result() int
}

//OperatorFactory 是工厂接口
type OperatorFactory interface {
    Create() Operator
}

//OperatorBase 是Operator 接口实现的基类,封装公用方法
type OperatorBase struct {
    a, b int
}

//SetA 设置 A
func (o *OperatorBase) SetA(a int) {
    o.a = a
}

//SetB 设置 B
func (o *OperatorBase) SetB(b int) {
    o.b = b
}

//PlusOperatorFactory 是 PlusOperator 的工厂类
type PlusOperatorFactory struct{}

func (PlusOperatorFactory) Create() Operator {
    return &PlusOperator{
        OperatorBase: &OperatorBase{},
    }
}

//PlusOperator Operator 的实际加法实现
type PlusOperator struct {
    *OperatorBase
}

//Result 获取结果
func (o PlusOperator) Result() int {
    return o.a + o.b
}

//MinusOperatorFactory 是 MinusOperator 的工厂类
type MinusOperatorFactory struct{}

func (MinusOperatorFactory) Create() Operator {
    return &MinusOperator{
        OperatorBase: &OperatorBase{},
    }
}

//MinusOperator Operator 的实际减法实现
type MinusOperator struct {
    *OperatorBase
}

//Result 获取结果
func (o MinusOperator) Result() int {
    return o.a - o.b
}

factorymethod_test.go

package factorymethod

import "testing"

func compute(factory OperatorFactory, a, b int) int {
    op := factory.Create()
    op.SetA(a)
    op.SetB(b)
    return op.Result()
}

func TestOperator(t *testing.T) {
    var (
        factory OperatorFactory
    )

    factory = PlusOperatorFactory{}
    if compute(factory, 1, 2) != 3 {
        t.Fatal("error with factory method pattern")
    }

    factory = MinusOperatorFactory{}
    if compute(factory, 4, 2) != 2 {
        t.Fatal("error with factory method pattern")
    }
}
Golang 中的工厂模式是一种常见的设计模式,用于创建对象而无需指定其具体类型。它通过提供一个共同的接口来创建不同类型的对象,并将对象的实例化过程封装起来。这样,客户端代码只需要和工厂接口进行交互,而不用关心具体对象的创建细节。 下面是一个简单的示例,展示了如何在 Golang 中实现工厂模式: ```go package main import "fmt" // 定义接口 type Animal interface { Speak() string } // 定义结构体和方法 type Cat struct{} func (c Cat) Speak() string { return "Meow" } type Dog struct{} func (d Dog) Speak() string { return "Woof" } // 定义工厂函数 func NewAnimal(animalType string) Animal { switch animalType { case "cat": return Cat{} case "dog": return Dog{} default: return nil } } func main() { // 使用工厂函数创建对象 cat := NewAnimal("cat") fmt.Println(cat.Speak()) // 输出 "Meow" dog := NewAnimal("dog") fmt.Println(dog.Speak()) // 输出 "Woof" } ``` 在上述示例中,我们定义了一个 Animal 接口以及两个结构体 Cat 和 Dog,它们都实现了 Animal 接口中的 Speak() 方法。然后,我们实现了一个工厂函数 NewAnimal,根据传入的参数来创建相应的具体对象。 通过使用工厂函数,我们可以根据需要创建不同类型的 Animal 对象,而不需要直接调用具体的结构体构造函数。这样可以提高代码的灵活性和可维护性,同时将对象的创建逻辑封装起来,使得客户端代码更加简洁和易于理解。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值