设计模式–抽象工厂模式（go语言描述）

抽象工厂模式中通常包含以下几种角色:

1. Factory(抽象工厂): 与工厂方法模式不同的是，抽象工厂声明了一族产品的生产方法，每一个方法都对应于一种产品。
2. ConcreteFactory(具体工厂): 实现了抽象工厂中声明的方法。每个具体工厂负责生产一族产品。
3. Product(抽象产品): 与工厂方法模式相同，都定义了一类产品所应实现的方法。
4. Concrete(具体产品): 实现了抽象产品定义的业务方法，对应于一种具体的产品。

package main

import "fmt"

// 抽象工厂：定义接口
type AbstractFactory interface {
    WheelMethod() Wheel
    EngineMethod() Engine
}

// BMW具体工厂，生产一族产品
type BMWFactory struct{}

func (f *BMWFactory) WheelMethod() Wheel {
    return &BMWWheel{}
}

func (f *BMWFactory) EngineMethod() Engine {
    return &BMWEngine{}
}

// Audi具体工厂，生产一族产品
type AudiFactory struct{}

func (f *AudiFactory) WheelMethod() Wheel {
    return &AudiWheel{}
}

func (f *AudiFactory) EngineMethod() Engine {
    return &AudiEngine{}
}

/* ----------------------------------------- */
// 引擎抽象产品
type Engine interface {
    Start()
}

// BMW引擎
type BMWEngine struct{}

func (b *BMWEngine) Start() {
    fmt.Printf("BMW's Enginen")
}

// Audi引擎
type AudiEngine struct{}

func (a *AudiEngine) Start() {
    fmt.Printf("Audi's Enginen")
}

/* ----------------------------------------- */
// 轮胎抽象产品
type Wheel interface {
    Run()
}

// BMW轮胎
type BMWWheel struct{}

func (b *BMWWheel) Run() {
    fmt.Printf("BMW's Wheeln")
}

// Audi轮胎
type AudiWheel struct{}

func (a *AudiWheel) Run() {
    fmt.Printf("Audi's Wheeln")
}

func main() {
    bmwFactory := &BMWFactory{}
    wheel := bmwFactory.WheelMethod()
    wheel.Run()
    // output: BMW's Wheel
    engine := bmwFactory.EngineMethod()
    engine.Start()
    // output: BMW's Engine

    audiFactory := &AudiFactory{}
    wheel = audiFactory.WheelMethod()
    wheel.Run()
    // output: Audi's Wheel
    engine = audiFactory.EngineMethod()
    engine.Start()
    // output: Audi's Engine
}

抽象工厂模式中，工厂类不再局限于生产一类产品，而是可以生产一族产品，当只有一种产品等级结构时，抽象工厂模式会退化成工厂方法模式。
在抽象工厂模式中，接口与实现进行了分离，客户端只需要面对接口编程，而不需要知道具体的产品实现。在不同之间的产品族进行切换，只需要通过配置文件动态地切换具体工厂。
增加一族产品只需要增加具体产品及其对应的工厂即可，对已有的代码不需要进行任何修改；而增加一种新的产品等级接口，却需要修改抽象工厂及其全部的子类工厂，增加新产品的生产方法，违背了”开闭原则“。

参考：