关于设计模式:设计模式工厂方法Factory-Method模式

模式定义

定义一个用于创建对象的接口，让子类决定实例化哪一个类，使得一个类的实例化提早到子类

类图

利用场景

1. 当你不晓得该应用对象的确切类型的时候；

2. 当你心愿为库或框架提供扩大其外部组件的办法时。

次要长处

1. 将具体产品和创建者解耦；

2. 合乎繁多职责准则；

3. 合乎开闭准则。

要点总结

• Factory Method 模式用于隔离类对象的使用者和具体类型之间的耦合关系。面对一个常常变动的具体类型，紧耦合关系（new）会导致软件的软弱
• Factory Method 模式通过面向对象的手法，将所要创立的具体对象工作提早到子类，从而实现一种扩大（而非更改）的策略，较好地解决了这种紧耦合关系
• Factory Method 模式解放了“单个对象”的需要变动，毛病在于要求创立办法、参数雷同

Go 语言实现

工程目录

OperatorFactory.go

package Factory

// 理论运行类的接口
type Operator interface {SetLeft(int)
   SetRight(int)
   Result() int}

// 工厂接口
type OperatorFactory interface {Create() Operator
}

OperatorData.go

package Factory

// 数据
type OperatorData struct {left, right int}

// 赋值
func (op *OperatorData) SetLeft(left int) {op.left = left}

func (op *OperatorData) SetRight(right int) {op.right = right}

PlusOpertaorFactory.go

package Factory

// 操作的形象
type PlusOpertaorFactory struct {}

// 操作类中蕴含操作数
type PlusOpertaor struct {*OperatorData}

// 理论运行办法
func(o PlusOpertaor) Result() int {return o.right + o.left}
func(PlusOpertaorFactory) Create() Operator {return &PlusOpertaor{&OperatorData{}}
}

SubOpertaorFactory.go

package Factory

// 操作的形象
type SubOpertaorFactory struct {}

// 操作类中蕴含操作数
type SubOpertaor struct {*OperatorData}

// 理论运行办法
func(o SubOpertaor) Result() int {return o.left - o.right}
func(SubOpertaorFactory) Create() Operator {return &SubOpertaor{&OperatorData{}}
}

factory_test.go

package Factory

import (
   "fmt"
   "testing"
)

func TestOpertaorFactory(t *testing.T) {
   var fac OperatorFactory
   fac = PlusOpertaorFactory{}
   op := fac.Create()
   op.SetLeft(20)
   op.SetRight(10)
   fmt.Println(op.Result())

   fac = SubOpertaorFactory{}
   op = fac.Create()
   op.SetLeft(30)
   op.SetRight(20)
   fmt.Println(op.Result())
}