go语言中的面向对象，接口类型，工厂设计模式解读

工厂模式：

定义一个用于创建对象的接口，让子类决定实例化哪一个类
抽象工厂模式：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类
个人觉得这个区别在于产品，如果产品单一，最合适用工厂模式，但是如果有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。再通俗深化理解下：工厂模式针对的是一个产品等级结构 ，抽象工厂模式针对的是面向多个产品等级结构的。
工厂方法模式 抽象工厂模式
针对的是一个产品等级结构 针对的是面向多个产品等级结构
一个抽象产品类 多个抽象产品类
可以派生出多个具体产品类 每个抽象产品类可以派生出多个具体产品类
一个抽象工厂类，可以派生出多个具体工厂类 一个抽象工厂类，可以派生出多个具体工厂类
每个具体工厂类只能创建一个具体产品类的实例 每个具体工厂类可以创建多个具体产品类的实例
加减乘除四则运算器工厂模式举例子

package main
import "fmt"
type operation struct{  //定义一个父类两个数据
    num1 float64
    num2 float64
}
type operationAdd struct{   //加法子类
    operation
}
func (op *operationAdd)getresult()float64{ //加法类的方法
    return op.num1+op.num2
}
type operationSub struct{          //减法子类
    operation
}
func (sub *operationSub)getresult()float64{ //减法类的方法
    return sub.num1-sub.num2
}
type operationMult struct{    //乘法子类
    operation
}
func (mult *operationMult)getresult()float64{
    return mult.num1*mult.num2
}
type operationDivi struct{
    operation
}                          //除法子类
func (divi *operationDivi)getresult()float64{
    return divi.num1/divi.num2
}

type operationer interface{    //定义接口
    getresult() float64     //加法的方法
}
type operationfactor struct {
    //operation                  //用于创建对象的类，工厂模式
}
func (op *operationfactor)creatoperation(ope string,num1 float64,num2 float64)float64{  //用于构件对象类
    var result float64
    switch ope {
    case "+":
        add:=&operationAdd{operation{num1,num2}}  //按照传过来的符号来创建相应的对象
        result=operationwho(add)   //传递给多态的函数，直接调用
    case "-":
        sub:=&operationSub{operation{num1,num2}}
        result=operationwho(sub)
    case "*":
        mult:=&operationMult{operation{num1,num2}}
        result=operationwho(mult)
    case "/":
        divi:=&operationDivi{operation{num1,num2}}
        result=operationwho(divi)
    }
    return result
}
func operationwho(i operationer)float64{
    return i.getresult() //此处为创建一个多态的函数
}
func main(){
    //m:=&operationAdd{operation{3,4}}
    //var iop operationer
    //iop=m
    //sum:=iop.getresult()
    //fmt.Println(sum)
    var op1 operationfactor  //直接创建工厂类对象
    sum:=op1.creatoperation("+",9,6) //直接调用工厂类的方法
    fmt.Println(sum)
    var op2 operationfactor
    sub:=op2.creatoperation("-",9,8)
    fmt.Println(sub)
    var op3 operationfactor
    mult:=op3.creatoperation("*",3,4)
    fmt.Println(mult)
    var op4 operationfactor
    div:=op4.creatoperation("/",9,10)
    fmt.Println(div)
}

在上面的例子当中，如果对面向对象没有接触的话可能会有一些不好理解，在go语言当中面向对象可能和别的语言有一些不同，go语言是利用匿名字段来实现继承，在上面的例子中多态函数的实现可以让函数调用更加方便，比如每个结构体类都有10几个甚至更多的函数，那么直接都把这些函数封装在多态的函数里面，那么每次调用直接传递一个结构体类给多态函数就直接全部调用了，这样就是很方便的