关于设计模式:设计模式工厂方法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())
}