1. 概述

1.1 角色

AbstractFactory（抽象工厂）：它声明了一组用于创建产品的方法，每一个方法对应一种产品。
ConcreteFactory（具体工厂）：它实现了在抽象工厂中声明的创建产品的方法，生成一组具体产品，这些产品构成了一个产品族，每一个产品都位于某个产品等级结构中。
AbstractProduct（抽象产品）：它为每种产品声明接口，在抽象产品中声明了产品所具有的业务方法。
ConcreteProduct（具体产品）：它定义具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法。

1.2 类图

2. 代码示例

2.1 设计

定义抽象产品A
- 定义具体产品A-1
  - 它有Name、Weight两个成员
  - 它的SetName()、SetWeight()两个方法分别负责设置以上两个成员
  - 它的Get()方法获取它本身的信息
- 定义具体产品A-2
  - 它有Name、Weight两个成员
  - 它的SetName()、SetWeight()两个方法分别负责设置以上两个成员
  - 它的Get()方法获取它本身的信息
定义抽象产品B
- 定义具体产品B-1
  - 它有Name、Height两个成员
  - 它的SetName()、SetHeight()两个方法分别负责设置以上两个成员
  - 它的Get()方法获取它本身的信息
- 定义具体产品B-2
  - 它有Name、Height两个成员
  - 它的SetName()、SetHeight()两个方法分别负责设置以上两个成员
  - 它的Get()方法获取它本身的信息
定义抽象工厂
- 定义具体工厂1
  - 它的方法SetProductA()设置具体产品A-1
  - 它的方法SetProductB()设置具体产品B-1
- 定义具体工厂2
  - 它的方法SetProductA()设置具体产品A-2
  - 它的方法SetProductB()设置具体产品B-2
定义一个函数CreateFactory()，用来创建具体工厂
调用
- 用CreateFactory()函数实例化 具体工厂1——factory1
- 用factory1实例化产品A-1和产品B-1，并查看结果
- 用CreateFactory()函数实例化 具体工厂2——factory2
- 用factory2实例化产品A-2和产品B-2，并查看结果

2.2 代码

package main

import "fmt"

// 定义抽象产品A
type AbstractProductA interface {
	SetName(name string)
	SetWeight(weight int64)
	Get()
}

// 定义具体产品A-1
type ConcreteProductA1 struct {
	Name   string
	Weight int64
}

func (c *ConcreteProductA1) SetName(name string) {
	c.Name = name
}

func (c *ConcreteProductA1) SetWeight(weight int64) {
	c.Weight = weight
}

func (c *ConcreteProductA1) Get() {
	fmt.Printf("%v\n", c)
}

// 定义具体产品A-2
type ConcreteProductA2 struct {
	Name   string
	Weight int64
}

func (c *ConcreteProductA2) SetName(name string) {
	c.Name = name
}

func (c *ConcreteProductA2) SetWeight(weight int64) {
	c.Weight = weight
}
func (c *ConcreteProductA2) Get() {
	fmt.Printf("%v\n", c)
}

// 定义抽象产品B
type AbstractProductB interface {
	SetName(name string)
	SetHeight(height int64)
	Get()
}

// 定义具体抽象产品B-1
type ConcreteProductB1 struct {
	Name   string
	Height int64
}

func (c *ConcreteProductB1) SetName(name string) {
	c.Name = name
}

func (c *ConcreteProductB1) SetHeight(height int64) {
	c.Height = height
}
func (c *ConcreteProductB1) Get() {
	fmt.Printf("%v\n", c)
}

// 定义具体产品B-2
type ConcreteProductB2 struct {
	Name   string
	Height int64
}

func (c *ConcreteProductB2) SetName(name string) {
	c.Name = name
}

func (c *ConcreteProductB2) SetHeight(height int64) {
	c.Height = height
}
func (c *ConcreteProductB2) Get() {
	fmt.Printf("%v\n", c)
}

// Factory部分

// 定义抽象工厂
type Factory interface {
	SetProductA(name string, weight int64) AbstractProductA
	SetProductB(name string, height int64) AbstractProductB
}

// 定义具体工厂1
type Factory1 struct {
}

func (f *Factory1) SetProductA(name string, weight int64) AbstractProductA {
	a := &ConcreteProductA1{}
	a.SetName(name)
	a.SetWeight(weight)
	return a
}

func (f *Factory1) SetProductB(name string, height int64) AbstractProductB {
	a := &ConcreteProductB1{}
	a.SetName(name)
	a.SetHeight(height)
	return a
}

// 定义具体工厂2
type Factory2 struct {
}

func (f *Factory2) SetProductA(name string, weight int64) AbstractProductA {
	a := &ConcreteProductA2{}
	a.SetName(name)
	a.SetWeight(weight)
	return a
}

func (f *Factory2) SetProductB(name string, height int64) AbstractProductB {
	a := &ConcreteProductB2{}
	a.SetName(name)
	a.SetHeight(height)
	return a
}

// 写一个创建工厂的函数
func CreateFactory(pType int64) Factory {
	switch pType {
	case 1:
		return &Factory1{}
	case 2:
		return &Factory2{}
	}
	return nil
}

func main() {
	factory1 := CreateFactory(1)
	factory1.SetProductA("A1", 3).Get()
	factory1.SetProductB("B1", 3).Get()
	
	factory2 := CreateFactory(2)
	factory2.SetProductA("A2", 4).Get()
	factory2.SetProductB("B2", 4).Get()
}