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

一、面向对象编程

1、可维护性

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

2、可复用性

　　将一定的代码进行封装，在多处可以重复使用。

3、可扩展性

　　当增加新的功能模块时，只需要增加某些代码，对整体代码架构不需要做太多修改。

4、高灵活性

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

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

　　学习的来源是程杰的《大话数据模式》，书中的例子比较易懂，故事也具有连续性。本文的语言继续使用我最近学习的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判断,再在主程序中添加操作便可。整个代码的耦合度大大降低，灵活性也得到了提高。