GoLang设计模式02 - 工厂模式
工厂模式是一种创建型模式，也是最常用的设计模式之一。调用方通过工厂产出并获取对象，可以不必关注对象创建的细节和构建逻辑。
在工厂模式下，调用方只和工厂进行交互，并告诉工厂具体获取哪种类型的对象。工厂负责和相应的struct交互，并返回需要的对象。
如下是工厂模式的UML类图：
接下来是一个工厂模式的范例，在这个例子中：
- 提供了一个接口
iGun，定义了一把枪应该有的各种方法 - 提供了一个名为
gun的类，并实现了iGun接口 - 两个具体类
ak47和maverick(卡宾枪，一种突击步枪)，两者都组装了gunstruct，实现了iGun的的各种方法，因此它们也可以说是iGun的子类， - 核心是名为
gunFactory的struct，它可以产出ak47和maverick的实例。 - 最后，是
main.go文件及其中的main()方法，可以被视为是调用方，它依赖了gunFactory来创建ak47和maverick的实例，并应用这两个实例。
这里是这个例子对应的类图：
具体代码如下：
iGun.go
| 1 2 3 4 5 6 7 8 |
package main
type iGun interface {
setName(name string)
setPower(power int)
getName() string
getPower() int
}
|
gun.go
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
package main
type gun struct {
name string
power int
}
func (g *gun) setName(name string) {
g.name = name
}
func (g *gun) getName() string {
return g.name
}
func (g *gun) setPower(power int) {
g.power = power
}
func (g *gun) getPower() int {
return g.power
}
|
ak47.go
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
package main
type ak47 struct {
gun
}
func newAk47() iGun {
return &ak47{
gun: gun{
name: "AK47 gun",
power: 4,
},
}
}
|
maverick.go
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
package main
type maverick struct {
gun
}
func newMaverick() iGun {
return &maverick{
gun: gun{
name: "Maverick gun",
power: 5,
},
}
}
|
gunFactory.go
| 1 2 3 4 5 6 7 8 9 10 11 12 13 |
package main
import "fmt"
func getGun(gunType string) (iGun, error) {
if gunType == "ak47" {
return newAk47(), nil
}
if gunType == "maverick" {
return newMaverick(), nil
}
return nil, fmt.Errorf("Wrong gun type passed")
}
|
main.go
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
package main
import "fmt"
func main() {
ak47, _ := getGun("ak47")
maverick, _ := getGun("maverick")
printDetails(ak47)
printDetails(maverick)
}
func printDetails(g iGun) {
fmt.Printf("Gun: %s", g.getName())
fmt.Println()
fmt.Printf("Power: %d", g.getPower())
fmt.Println()
}
|
代码已上传至GitHub：zhyea / go-patterns / factory-pattern
End！
仅是学习笔记，难免出错，望不吝指点 转 https://www.cnblogs.com/amunote/p/15231697.html