Golang設計模式-工廠模式

一.介紹

定義一個用於創建對象的接口，讓子類界定實例化哪個類。工廠方法使一個類的實例化延遲到子類。

二.工廠模式和簡單工廠模式的區別

       簡單工廠模式的最大優點在於工廠類中包含了必要的邏輯判斷，根據客戶的選擇動態實例化相關的類，對於客戶端來說，去除了與具體產品的依賴。如果是翻譯，讓客戶端不管用哪個類的實例，只需把翻譯類型（int  1，2，3）給工廠，工廠自動給出了相應的實例，客戶只管去運行，不同的實例會實現不同的翻譯結果。但如果要加一個新的翻譯語言，我們就要在運算工廠裏的方法加‘Case’分支條件的，修改原有的類，相當於我們不但對擴展開放對修改也開放了，違反了“開放-封閉原則”。

三.代碼

 

package main

import (
    "fmt"
)

type Operation struct {
    a float64
    b float64
}

type OperationI interface {
    GetResult() float64
    SetA(float64)
    SetB(float64)
}

func (op *Operation) SetA(a float64) {
    op.a = a
}

func (op *Operation) SetB(b float64) {
    op.b = b
}

type AddOperation struct {
    Operation
}

func (this *AddOperation) GetResult() float64 {
    return this.a + this.b
}

type SubOperation struct {
    Operation
}

func (this *SubOperation) GetResult() float64 {
    return this.a - this.b
}

type MulOperation struct {
    Operation
}

func (this *MulOperation) GetResult() float64 {
    return this.a * this.b
}

type DivOperation struct {
    Operation
}

func (this *DivOperation) GetResult() float64 {
    return this.a / this.b
}

type IFactory interface {
    CreateOperation() Operation
}

type AddFactory struct {
}

func (this *AddFactory) CreateOperation() OperationI {
    return &(AddOperation{})
}

type SubFactory struct {
}

func (this *SubFactory) CreateOperation() OperationI {
    return &(SubOperation{})
}

type MulFactory struct {
}

func (this *MulFactory) CreateOperation() OperationI {
    return &(MulOperation{})
}

type DivFactory struct {
}

func (this *DivFactory) CreateOperation() OperationI {
    return &(DivOperation{})
}

func main() {
    fac := &(AddFactory{})
    oper := fac.CreateOperation()
    oper.SetA(1)
    oper.SetB(2)
    fmt.Println(oper.GetResult())
}

四.總結

       根據依賴倒置原則，我們把工廠類抽象出一個接口，這個接口只有一個方法，就是創建抽象產品的工廠方法。然後，所有的要生產具體類的工廠，就要去實現這個接口。這樣一個簡單工廠的工廠類，變成一個工廠抽象接口和多個具體生產對象的工廠，於是我們要增加一個新的邏輯運算，就不需要更改原來的工廠類了，只需要增加此功能的運算類和對應的工廠類就可以了。