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几个甚至更多的函数，那么直接都把这些函数封装在多态的函数里面，那么每次调用直接传递一个结构体类给多态函数就直接全部调用了，这样就是很方便的

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

猜你喜欢