Golang设计模式之工厂

Jackey Golang 2,698 次浏览 , , 没有评论

新建 OperatorFactory.go

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
package factory
// 实际运行类的接口
type Operator interface {
SetLeft(int)
SetRight(int)
Result() int
}
// 工厂接口
type OperatorFactory interface {
Create() Operator
}
package factory // 实际运行类的接口 type Operator interface { SetLeft(int) SetRight(int) Result() int } // 工厂接口 type OperatorFactory interface { Create() Operator }
package factory

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

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

新建OperatorBase.go

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
package factory
// 数据
type OperatorBase struct {
left, right int
}
// 赋值
func (o *OperatorBase) SetLeft(left int) {
o.left = left
}
func (o *OperatorBase) SetRight(right int) {
o.right = right
}
package factory // 数据 type OperatorBase struct { left, right int } // 赋值 func (o *OperatorBase) SetLeft(left int) { o.left = left } func (o *OperatorBase) SetRight(right int) { o.right = right }
package factory

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

// 赋值
func (o *OperatorBase) SetLeft(left int) {
    o.left = left
}

func (o *OperatorBase) SetRight(right int) {
    o.right = right
}

新建PlusOperatorFactory.go

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
package factory
// 操作的抽象 加法工厂
type PlusOperatorFactory struct {
}
// 操作勒种包含操作数
type PlusOperator struct {
*OperatorBase
}
// 实际运行
func (p *PlusOperator) Result() int {
return p.right + p.left
}
func (PlusOperatorFactory) Create() Operator {
return &PlusOperator{&OperatorBase{}}
}
package factory // 操作的抽象 加法工厂 type PlusOperatorFactory struct { } // 操作勒种包含操作数 type PlusOperator struct { *OperatorBase } // 实际运行 func (p *PlusOperator) Result() int { return p.right + p.left } func (PlusOperatorFactory) Create() Operator { return &PlusOperator{&OperatorBase{}} }
package factory

// 操作的抽象 加法工厂
type PlusOperatorFactory struct {
}

// 操作勒种包含操作数
type PlusOperator struct {
    *OperatorBase
}

// 实际运行
func (p *PlusOperator) Result() int {
    return p.right + p.left
}

func (PlusOperatorFactory) Create() Operator {
    return &PlusOperator{&OperatorBase{}}
}

新建SubOperatorFactory.go

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
package factory
// 操作的抽象 减法工厂
type SubOperatorFactory struct {
}
// 操作勒种包含操作数
type SubOperator struct {
*OperatorBase
}
// 实际运行
func (p *SubOperator) Result() int {
return p.left - p.right
}
func (SubOperatorFactory) Create() Operator {
return &SubOperator{&OperatorBase{}}
}
package factory // 操作的抽象 减法工厂 type SubOperatorFactory struct { } // 操作勒种包含操作数 type SubOperator struct { *OperatorBase } // 实际运行 func (p *SubOperator) Result() int { return p.left - p.right } func (SubOperatorFactory) Create() Operator { return &SubOperator{&OperatorBase{}} }
package factory

// 操作的抽象 减法工厂
type SubOperatorFactory struct {
}

// 操作勒种包含操作数
type SubOperator struct {
    *OperatorBase
}

// 实际运行
func (p *SubOperator) Result() int {
    return p.left - p.right
}

func (SubOperatorFactory) Create() Operator {
    return &SubOperator{&OperatorBase{}}
}

main.go

Plain text
Copy to clipboard
Open code in new window
EnlighterJS 3 Syntax Highlighter
package main
import (
"fmt"
"test/design/factory"
)
// A X B
// X 代表操作
// A B 代表操作数
// X=+ A+B X=- A-B X=% A%B
// left, right
func main() {
var fac factory.OperatorFactory
//fac = PlusOperatorFactory{}
fac = factory.SubOperatorFactory{}
op := fac.Create()
op.SetLeft(20)
op.SetRight(10)
fmt.Println(op.Result())
}
package main import ( "fmt" "test/design/factory" ) // A X B // X 代表操作 // A B 代表操作数 // X=+ A+B X=- A-B X=% A%B // left, right func main() { var fac factory.OperatorFactory //fac = PlusOperatorFactory{} fac = factory.SubOperatorFactory{} op := fac.Create() op.SetLeft(20) op.SetRight(10) fmt.Println(op.Result()) }
package main

import (
    "fmt"
    "test/design/factory"
)

// A   X    B
// X 代表操作
// A B 代表操作数
// X=+ A+B   X=-   A-B    X=%  A%B
// left, right

func main() {
    var fac factory.OperatorFactory
    //fac = PlusOperatorFactory{}
    fac = factory.SubOperatorFactory{}
    op := fac.Create()
    op.SetLeft(20)
    op.SetRight(10)
    fmt.Println(op.Result())
}

 

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

Go