抽象工厂模式

工厂方法模式

咖啡接口

package abstractFactory

type coffer interface{
    addMilk()
	addSugar()
	getName() string
}

咖啡

package abstractFactory

type coffee struct{
    name string
}

中式咖啡

package abstractFactory

type chinaCoffee struct {
    coffee
}

func NewChinaCoffee() *chinaCoffee{
    cof := new(chinaCoffee)
    cof.name = "中式咖啡"
    return cof
}

func (c *chinaCoffee)addMilk(){
    fmt.Println("加入三分之一汤匙牛奶！")
} 

func (c *chinaCoffee)addSugar(){
    fmt.Println("加入10克白糖！")
}

func (c *chinaCoffee)getName() string{
    return c.name
}

美式咖啡

package abstractFactory

type americanCoffee struct {
    coffee
}

func NewAmericanCoffee() *americanCoffee{
    cof := new(americanCoffee)
    cof.name = "美式咖啡"
    return cof
}

func (a *americanCoffee)addMilk(){
    fmt.Println("加入一汤匙牛奶！")
}

func (a *americanCoffee)addSugar(){
    fmt.Println("加入20克白糖！")
}

func (a *americanCoffee)getName() string{
    return a.name
}

蛋糕接口

package abstractFactory

type caker interface{
    bake()
    cut()
    getName() string
}

蛋糕

package abstractFactory

type cake struct{
    name string
}

生日蛋糕

package abstractFactory

type birthdayCake struct{
    cake
}

func NewBirthdayCake() *birthdayCake{
    bcake := new(birthdayCake)
    bcake.name = "生日蛋糕"
    return bcake
}

func (b *birthdayCake)bake(){
    fmt.Println("烘焙15分钟！")
}

func (b *birthdayCake)cut(){
    fmt.Println("送顾客刀叉，自己分割！")
}

func (b *birthdayCake)getName()string{
    return b.name
}

肉松蛋糕

package abstractFactory

type meatCake struct{
    cake
}

func NewMeatCake() *meatCake{
    mcake := new(meatCake)
    mcake.name = "肉松蛋糕"
    return mcake
}

func (m *meatCake)bake(){
    fmt.Println("烘焙20分钟！")
}

func (m *meatCake)cut(){
    fmt.Println("根据购买重量分割！")
}

func (m *meatCake)getName()string{
    return m.name
}

工厂方法接口

package abstractFactory

type factoryMethod interface{
    createCoffee() coffer
    createCake() caker
}

城北店

package abstractFactory

type northFactory struct{}

func NewnorthFactory() *northFactory{
    return new(northFactory)
}

func (n *northFactory)createCoffee() coffer{
    ncof := NewChinaCoffee()
    ncof.addMilk()
    ncof.addSugar()
    
    return ncof
}

func (n *northFactory)createCake() caker{
    ncake := NewBirthdayCake()
    ncake.bake()
    ncake.cut()
    
    return ncake
}

中心店

package abstractFactory

type centerFactory struct{}

func NewCenterFactory() *centerFactory{
    return new(centerFactory)
}

func(c *centerFactory)createCoffee() coffer{
    ccof := NewAmericanCoffee()
    ccof.addMilk()
    ccof.addSugar()
    
    return ccof
}

func (n *centerFactory)createCake() caker{
    ncake := NewMeatCake()
    ncake.bake()
    ncake.cut()
    
    return ncake
}

测试文件

package abstractFactory

func TestAbstractFactory(t *testing.T) {
	f1 := NewnorthFactory()
	coffee := f1.createCoffee()
	fmt.Println(coffee.getName())
	cake := f1.createCake()
	fmt.Println(cake.getName())

	f2 := NewcenterFactory()
	coffee = f2.createCoffee()
	fmt.Println(coffee.getName())
	cake = f2.createCake()
	fmt.Println(cake.getName())
}