二.工厂模式和简单工厂模式的区别

一.介绍

定义一个用于创建对象的接口，让子类界定实例化哪个类。工厂方法使一个类的实例化延迟到子类。

二.工厂模式和简单工厂模式的区别

       简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户的选择动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。如果是翻译，让客户端不管用哪个类的实例，只需把翻译类型（int  1，2，3）给工厂，工厂自动给出了相应的实例，客户只管去运行，不同的实例会实现不同的翻译结果。但如果要加一个新的翻译语言，我们就要在运算工厂里的方法加‘Case’分支条件的，修改原有的类，相当于我们不但对扩展开放对修改也开放了，违反了“开放-封闭原则”。

三.代码

 

package main

import (
    "fmt"
)

type Operation struct {
    a float64
    b float64
}

type OperationI interface {
    GetResult() float64
    SetA(float64)
    SetB(float64)
}

func (op *Operation) SetA(a float64) {
    op.a = a
}

func (op *Operation) SetB(b float64) {
    op.b = b
}

type AddOperation struct {
    Operation
}

func (this *AddOperation) GetResult() float64 {
    return this.a + this.b
}

type SubOperation struct {
    Operation
}

func (this *SubOperation) GetResult() float64 {
    return this.a - this.b
}

type MulOperation struct {
    Operation
}

func (this *MulOperation) GetResult() float64 {
    return this.a * this.b
}

type DivOperation struct {
    Operation
}

func (this *DivOperation) GetResult() float64 {
    return this.a / this.b
}

type IFactory interface {
    CreateOperation() Operation
}

type AddFactory struct {
}

func (this *AddFactory) CreateOperation() OperationI {
    return &(AddOperation{})
}

type SubFactory struct {
}

func (this *SubFactory) CreateOperation() OperationI {
    return &(SubOperation{})
}

type MulFactory struct {
}

func (this *MulFactory) CreateOperation() OperationI {
    return &(MulOperation{})
}

type DivFactory struct {
}

func (this *DivFactory) CreateOperation() OperationI {
    return &(DivOperation{})
}

func main() {
    fac := &(AddFactory{})
    oper := fac.CreateOperation()
    oper.SetA(1)
    oper.SetB(2)
    fmt.Println(oper.GetResult())
}

四.总结

       根据依赖倒置原则，我们把工厂类抽象出一个接口，这个接口只有一个方法，就是创建抽象产品的工厂方法。然后，所有的要生产具体类的工厂，就要去实现这个接口。这样一个简单工厂的工厂类，变成一个工厂抽象接口和多个具体生产对象的工厂，于是我们要增加一个新的逻辑运算，就不需要更改原来的工厂类了，只需要增加此功能的运算类和对应的工厂类就可以了。