之前我们介绍了工厂设计模式，现在我们再看一下抽象工厂设计模式。抽象工程模式顾名思义就是对工厂模式的一层抽象，也是创建型模式的一种，通常用来创建一组存在相关性的对象。
UML类图大致如下：
类图比较复杂，最好用个例子来说明。比方说，国内有两家生产运动服的工厂：nike和adidas 。现在我们想购买一套运动服，包含短裤（short）和运动鞋（shoe）。通常我们都会在同一家工厂购买整套的运动服。这时抽象工厂模式就可以发挥作用了。
现在我们需要的产品有两种：短裤（short）和运动鞋（shoe）。
生产这些产品的工厂有两家：nike和adidas。
nike和adidas都是运动服厂商，可以视为是 iSportsFactory接口的实现
然后，我们还要为具体的产品定义两个接口：
-
iShort，它有两个实现，分别是nikeShort和adidasShort -
iShoe，它也有两个实现，分别是nikeShoe和adidasShoe
看下具体的代码：
iSportsFactory.go
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
package main
import "fmt"
type iSportsFactory interface {
makeShoe() iShoe
makeShort() iShort
}
func getSportsFactory(brand string) (iSportsFactory, error) {
if brand == "adidas" {
return &adidas{}, nil
}
if brand == "nike" {
return &nike{}, nil
}
return nil, fmt.Errorf("Wrong brand type passed")
}
|
iShort.go
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
package main
type iShort interface {
setLogo(logo string)
setSize(size int)
getLogo() string
getSize() int
}
type short struct {
logo string
size int
}
func (s *short) setLogo(logo string) {
s.logo = logo
}
func (s *short) getLogo() string {
return s.logo
}
func (s *short) setSize(size int) {
s.size = size
}
func (s *short) getSize() int {
return s.size
}
|
iShoe.go
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
package main
type iShoe interface {
setLogo(logo string)
setSize(size int)
getLogo() string
getSize() int
}
type shoe struct {
logo string
size int
}
func (s *shoe) setLogo(logo string) {
s.logo = logo
}
func (s *shoe) getLogo() string {
return s.logo
}
func (s *shoe) setSize(size int) {
s.size = size
}
func (s *shoe) getSize() int {
return s.size
}
|
nike.go
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
package main
type nike struct {
}
type nikeShoe struct {
shoe
}
type nikeShort struct {
short
}
func (n *nike) makeShoe() iShoe {
return &nikeShoe{
shoe: shoe{
logo: "nike",
size: 14,
},
}
}
func (n *nike) makeShort() iShort {
return &nikeShort{
short: short{
logo: "nike",
size: 14,
},
}
}
|
adidas.go
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
package main
type adidas struct {
}
type adidasShoe struct {
shoe
}
type adidasShort struct {
short
}
func (a *adidas) makeShoe() iShoe {
return &adidasShoe{
shoe: shoe{
logo: "adidas",
size: 14,
},
}
}
func (a *adidas) makeShort() iShort {
return &adidasShort{
short: short{
logo: "adidas",
size: 14,
},
}
}
|
main.go
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
package main
import "fmt"
func main() {
adidasFactory, _ := getSportsFactory("adidas")
nikeFactory, _ := getSportsFactory("nike")
nikeShoe := nikeFactory.makeShoe()
nikeShort := nikeFactory.makeShort()
adidasShoe := adidasFactory.makeShoe()
adidasShort := adidasFactory.makeShort()
printShoeDetails(nikeShoe)
printShortDetails(nikeShort)
printShoeDetails(adidasShoe)
printShortDetails(adidasShort)
}
func printShoeDetails(s iShoe) {
fmt.Printf("Logo: %s", s.getLogo())
fmt.Println()
fmt.Printf("Size: %d", s.getSize())
fmt.Println()
}
func printShortDetails(s iShort) {
fmt.Printf("Logo: %s", s.getLogo())
fmt.Println()
fmt.Printf("Size: %d", s.getSize())
fmt.Println()
}
|
代码已上传至GitHub：zhyea / go-patterns / abstract-factory-pattern
End！
仅是学习笔记，难免出错，望不吝指点 转 https://www.cnblogs.com/amunote/p/15236587.html