GoLang设计模式04 - 抽象工厂模式@

​ 我们已经知道，工厂方法模式只能生产单一产品，如果新增同一等级的产品，那么可以增加对应产品的工厂，既如现在有这样一个需求，我们需要手机和电脑两种产品，这两种产品可以看作是形成了一个产品族，我们需要一个工厂能够同时生产手机和电脑，显然工厂方法做不到这样，而抽象工厂就可以，抽象工厂具有一个可以生产产品族的接口，然后有不同的工厂去实现，相当于是一个可以生产工厂的工厂。

package abstractfactory

import "fmt"

// 抽象层
type AbstractApple interface {
    showApple()
}
type AbstractBanana interface {
    showBanana()
}
type AbstractPear interface {
    showPear()
}

// 抽象层 抽象工厂
type AbstractFactory interface {
    createApple() AbstractApple
    createBanana() AbstractBanana
    createPear() AbstractPear
}

//实现层
/*中国产品族*/
type chinaApple struct{}

func (c *chinaApple) showApple() {
    fmt.Println("i am china Apple")
}

type chinaBanana struct{}

func (c *chinaBanana) showBanana() {
    fmt.Println("i am china Banana")
}

type chinaPear struct{}

func (c *chinaPear) showPear() {
    fmt.Println("i am china Pear")
}

type chinaFactory struct{}

func (cf *chinaFactory) createApple() AbstractApple {
    var apple AbstractApple
    apple = new(chinaApple)
    return apple
}
func (cf *chinaFactory) createBanana() AbstractBanana {
    var banana AbstractBanana
    banana = new(chinaBanana)
    return banana
}
func (cf *chinaFactory) createPear() AbstractPear {
    var pear AbstractPear
    pear = new(chinaPear)
    return pear
}

/*日本产品族*/
type japanApple struct{}

func (j *japanApple) showApple() {
    fmt.Println("i am japan Apple")
}

type japanBanana struct{}

func (j *japanBanana) showBanana() {
    fmt.Println("i am japan Banana")
}

type japanPear struct{}

func (j *japanPear) showPear() {
    fmt.Println("i am japan Pear")
}

// 业务层
func main() {
    //1 需求：需要中国的苹果香蕉苹果梨
    //创建中国工厂
    var fac AbstractFactory
    fac = new(chinaFactory)
    //生产一个苹果
    var apple AbstractApple
    apple = fac.createApple()
    apple.showApple()
    //生产一个香蕉
    var banana AbstractBanana
    banana = fac.createBanana()
    banana.showBanana()
    //生产一个梨
    var pear AbstractPear
    pear = fac.createPear()
    pear.showPear()
}