天天学设计模式：简单工厂模式

1、面向对象编程

一、可维护性

　　当往后代码须要修改逻辑的时候，只须要修改某些类或者增长某些类，对主程序和大部分代码不须要修改，体现为可维护性。

二、可复用性

　　将必定的代码进行封装，在多处能够重复使用。

三、可扩展性

　　当增长新的功能模块时，只须要增长某些代码，对总体代码架构不须要作太多修改。

四、高灵活性

　　经过封装、继承、多态把程序的耦合度下降，耦合度下降后，使代码的使用更加灵活，更容易修改，易于复用。

 

2、简单工厂模式的实现——以计算器功能为例

　　学习的来源是程杰的《大话数据模式》，书中的例子比较易懂，故事也具备连续性。本文的语言继续使用我最近学习的Go语言。

　　首先先写一个计算器操做的接口：

type Operation interface {
    GetResult(numberA float32, numberB float32) (float32, error)
}

　　其中有一个函数GetResult()，接收两个float32的参数numberA和numberB，返回一个float32的结果和error的错误格式（多返回值是Go语言的特性）。同时Go语言的非侵入式继承也规定了，只要某个类实现了接口的全部方式，就等因而实现了该接口。

　　下面咱们写最基本的加减乘除类：

// 加法操做类
type OperationAdd struct {
}

// 实现GetResult方法
func (o *OperationAdd) GetResult(numberA float32, numberB float32) (float32,error) {
    return numberA + numberB, nil
}

// 减法操做类
type OperationSub struct {
}

// 实现GetResult方法
func (o *OperationSub) GetResult(numberA float32, numberB float32) (float32,error) {
    return numberA - numberB, nil
}

// 乘法操做类
type OperationMul struct {
}

// 实现GetResult方法
func (o *OperationMul) GetResult(numberA float32, numberB float32) (float32,error) {
    return numberA * numberB, nil
}

// 除法操做类
type OperationDiv struct {
}

// 实现GetResult方法
func (o *OperationDiv) GetResult(numberA float32, numberB float32) (float32,error) {
    if numberB == 0 {
        return 0, nil
    }
    return numberA / numberB, nil
}

　　各方法都实现了GetResult()方法后，已是实现了Operation接口。

　　由面向对象多态的性质，咱们编写简单工厂类：

// 操做工厂类
type OperationFactory struct {

}

func (o *OperationFactory) CreateOperation(operation string) (oper Operation) {
    switch operation {
    case "+":
        oper = new(OperationAdd)
    case "-":
        oper = new(OperationSub)
    case "*":
        oper = new(OperationMul)
    case "/":
        oper = new(OperationDiv)
    }
    return
}

　　oper是Operation类型，因为OpeartionAdd、OpeartionSub、OpeartionMul和OpeartionDiv都实现了Opeartion，因此能够赋值给oper。工厂类就提供了一个方法，根据传入的字符串，返回适合的对象。

　　下面编写主程序：

func main() {
    factory := new(OperationFactory)

    operation := factory.CreateOperation("+")
    fmt.Println(operation.GetResult(6,2))

    operation = factory.CreateOperation("-")
    fmt.Println(operation.GetResult(6,2))

    operation = factory.CreateOperation("*")
    fmt.Println(operation.GetResult(6,2))
    
    operation = factory.CreateOperation("/")
    fmt.Println(operation.GetResult(6,2))
}

　　可见，一样的operation对象，调用GetResult()方法，获得的结果不一样，形成结果不一样的缘由在于工厂对你传入的"+"、"-"、"*"和"/"进行判断返回了不一样的对象。

　　这样，下次咱们须要修改需求或者增长需求的时候，就只须要增长或者修改部分类的代码就能够了。

　　以增长平方操做为例，咱们首先须要新写一个OperationPower类，实现Operation接口。在OperationFactory工厂类中增长case判断,再在主程序中添加操做即可。整个代码的耦合度大大下降，灵活性也获得了提升。