工厂模式是一种创建型模式,也是最常用的设计模式之一。调用方通过工厂产出并获取对象,可以不必关注对象创建的细节和构建逻辑。
在工厂模式下,调用方只和工厂进行交互,并告诉工厂具体获取哪种类型的对象。工厂负责和相应的struct交互,并返回需要的对象。
如下是工厂模式的UML类图:
接下来是一个工厂模式的范例,在这个例子中:
- 提供了一个接口
iGun
,定义了一把枪应该有的各种方法 - 提供了一个名为
gun
的类,并实现了iGun
接口 - 两个具体类
ak47
和maverick
(卡宾枪,一种突击步枪),两者都组装了gun
struct,实现了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!
仅是学习笔记,难免出错,望不吝指点
工厂模式是一种创建型模式,也是最常用的设计模式之一。调用方通过工厂产出并获取对象,可以不必关注对象创建的细节和构建逻辑。
在工厂模式下,调用方只和工厂进行交互,并告诉工厂具体获取哪种类型的对象。工厂负责和相应的struct交互,并返回需要的对象。
如下是工厂模式的UML类图:
接下来是一个工厂模式的范例,在这个例子中:
- 提供了一个接口
iGun
,定义了一把枪应该有的各种方法 - 提供了一个名为
gun
的类,并实现了iGun
接口 - 两个具体类
ak47
和maverick
(卡宾枪,一种突击步枪),两者都组装了gun
struct,实现了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!
本站文章如无特殊说明,均为本站原创,如若转载,请注明出处:GoLang设计模式02 – 工厂模式 - Python技术站