簡易工廠主要是用來解決物件“建立”的問題。以下的例子取自《大話設計模式》中第一章，實現一個可擴充套件的“計算器”。當增加新的功能時，並不需改動原來已經實現的演算法。由於是簡易工廠，所以我們還是需要對工廠類進行相應修改。

1.首先，我們定義一個計算的介面

package calc

type CalcSuper interface {
    SetData(data ...interface{})
    CalcOperate() float64
}

2.接下來，我們實現這個介面的兩個實現類，分別是加法和減法
加法，就是用兩個數來相加:)

package calc

import
 
 "fmt"

type Add struct {
    Num1 float64
    Num2 float64
}

func NewAdd() *Add {
    instance := new(Add)
    return instance
}

func (a *Add) SetData(data ...interface{}) {
    if len(data) != 2 {
        fmt.Println("error,Need two parameters ")
        return
    }
    if _, ok := data[0].(float64
 
); !ok {
        fmt.Println("error,Need float64 parameters ")
        return
    }
    if _, ok := data[1].(float64); !ok {
        fmt.Println("error,Need float64 parameters ")
        return
    }
    a.Num1 = data[0].(float64)
    a.Num2 = data[1].(float64)
}

func (a Add) CalcOperate() float64 {
    return
 
 a.Num1 + a.Num2
}

減法，就是把兩個數相減:)，我感覺我好冷。。。

package calc

import "fmt"

type Subtraction struct {
    Num1 float64
    Num2 float64
}

func NewSubtraction() *Subtraction {
    instance := new(Subtraction)
    return instance
}

func (a *Subtraction) SetData(data ...interface{}) {
    if len(data) != 2 {
        fmt.Println("error,Need two parameters ")
        return
    }
    if _, ok := data[0].(float64); !ok {
        fmt.Println("error,Need float64 parameters ")
        return
    }
    if _, ok := data[1].(float64); !ok {
        fmt.Println("error,Need float64 parameters ")
        return
    }
    a.Num1 = data[0].(float64)
    a.Num2 = data[1].(float64)
}

func (a Subtraction) CalcOperate() float64 {
    return a.Num1 - a.Num2
}

3.下面到了大功告成的時候了，定義簡易工廠，來例項化這兩個類

package calc

type CalcFactory struct {
}

func NewCalcFactory() *CalcFactory {
    instance := new(CalcFactory)
    return instance
}

func (f CalcFactory) CreateOperate(opType string) CalcSuper {
    var op CalcSuper
    switch opType {
    case "+":
        op = NewAdd()
    case "-":
        op = NewSubtraction()
    default:
        panic("error ! dont has this operate")
    }
    return op
}

在這個簡易工廠，我們只傳入相應的運算方式，如“＋”，“－”，用來建立相關的運算策略。它會返回一個運算介面的例項，當我們得到這個例項，就能呼叫裡面的方法進行運算了。

4.測試

// 簡易工廠模式 project main.go
package main

import (
    . "calc"
    "fmt"
)

func main() {
    factory := NewCalcFactory()

    op := factory.CreateOperate("+")
    op.SetData(1.0, 2.0)
    fmt.Println(op.CalcOperate())

    op = factory.CreateOperate("-")
    op.SetData(1.0, 2.0)
    fmt.Println(op.CalcOperate())
    /*
        輸出：3
        -1
    */
}

現在，我們的簡易工廠模式就實現好了，當我們需要新增乘法運算，我們不必再修改或者編譯已經完成的加法和減法運算。我們只需要新增乘法相應的結構，並且在factory中加上一個新的switch分支，就可以完成乘法了。

因為go語言中不允許存在抽象類，這使得我實現了一個非常詭異的函式SetData(data …interface{})。它可以傳入多個任意物件，用來設定我們結構中需要的資料。這只是一個示例，具體簡易工廠有什麼其它作用，可以參考《重構與模式》中第6章：建立 的相關知識。講的非常的全面。