Go不是面向对象的语言，但是使用组合、嵌套和接口可以支持代码的复用和多态。关于结构体嵌套：外层结构体类型通过匿名嵌套一个已命名的结构体类型后就可以获得匿名成员类型的所有导出成员，而且也获得了该类型导出的全部的方法。比如下面这个例子：

type ShapeInterface interface {
    GetName() string
}

type Shape struct {
    name string
}

func (s *Shape) GetName() string {
    return s.name
}

type Rectangle struct {
    Shape
    w, h float64
}

Shape类型上定义了GetName()方法，而在矩形Rectangle的定义中匿名嵌套了Shape类型从而获得了成员name和成员方法GetName()，同时Rectangle和 Shape一样又都是ShapeInterface接口的实现。

我一开始以为这和面向对象的继承没有什么区别，把内部结构体看成是父类，通过嵌套一下结构体就能获得父类的方法，而且还能根据需要重写父类的方法，在实际项目编程中我也是这么用的。直到有一天......

由于我们这很多推广类促销类的需求很多，几乎每月两三次，每季度还有大型推广活动。产品经理也是绞尽脑汁想各种玩法来提高用户活跃和订单量。每次都是前面玩法不一样，但最后都是参与任务得积分啦、分享后抽奖啦。于是乎我就肩负起了设计通用化流程的任务。根据每次需求通用的部分设计了接口和基础的实现类型，同时预留了给子类实现的方法，应对每次不一样的前置条件，这不就是面向对象里经常干的事儿嘛。

为了好理解我们还是用上面那个ShapeInterface举例子。

type ShapeInterface interface {
    Area() float64
    GetName() string
    PrintArea()
}

// 标准形状，它的面积为0.0
type Shape struct {
    name string
}

func (s *Shape) Area() float64 {
    return 0.0
}

func (s *Shape) GetName() string {
    return s.name
}

func (s *Shape) PrintArea() {
    fmt.Printf("%s : Area %v\r\n", s.name, s.Area())
}

// 矩形 : 重新定义了Area方法
type Rectangle struct {
    Shape
    w, h float64
}

func (r *Rectangle) Area() float64 {
    return r.w * r.h
}

// 圆形  : 重新定义 Area 和PrintArea 方法
type Circle struct {
    Shape
    r float64
}

func (c *Circle) Area() float64 {
    return c.r * c.r * math.Pi
}

func (c *Circle) PrintArea() {
    fmt.Printf("%s : Area %v\r\n", c.GetName(), c.Area())
}

我们在ShapeInterface里增加了Area()和PrintArea()方法，因为每种形状计算面积的公式不一样，基础实现类型Shape里的Area只是简单返回了0.0，具体计算面积的任务交给组合Shape类型的Rectange类通过重写Area()方法实现，Rectange通过组合获得了Shape的PrintArea()方法就能打印出它自己的面积来。

到目前为止，这些还都是我的设想，规划完后自己感觉特兴奋，感觉自己已经掌握了组合（Composition）这种思想的精髓...... 按这个思路我就把整套流程都写完了，单元测试只测了每个子功能，前置条件太复杂加上我还管团队里的其他项目自己的时间不太富余，所以就交付给组里的伙伴们使用了让他们顺便帮我测试下整个流程，然后就现场翻车了......

我们把上面那个例子运行一下，为了能看出区别，又专门写了一个Circle类型并用这个类型重写了Area()和PrintArea()。

func main() {

    s := Shape{name: "Shape"}
    c := Circle{Shape: Shape{name: "Circle"}, r: 10}
    r := Rectangle{Shape: Shape{name: "Rectangle"}, w: 5, h: 4}

    listshape := []c{&s, &c, &r}

    for _, si := range listshape {
        si.PrintArea() //!! 猜猜哪个Area()方法会被调用 !! 
    }

}

运行后的输出结果如下：

Shape : Area 0
Circle : Area 314.1592653589793
Rectangle : Area 0

看出问题来了不，Rectangle通过组合Shape获得的PrintArea()方法并没有去调用Rectangle实现的Area()方法，而是去调用了Shape的Area()方法。Circle是因为自己重写了PrintArea()所以在方法里调用到了自身的Area()。

在项目里那个类似例子里PrintArea()比这里的复杂很多而且承载着标准化流程的职责，肯定是不能每组合一次自己去实现一遍PrintArea()方法啊，那叫什么设计，而且面子上也说不过去，对吧，好不容易炫一次技，可不能被打脸。

经过Google上一番搜索后找到了一些详细的解释，上面我们期待的那种行为叫做虚拟方法：期望PrintArea()会去调用重写的Area()。但是在Go语言里没有继承和虚拟方法，Shape.PrintArea()的定义是调用Shape.Area()， Shape不知道它是否被嵌入哪个结构中，因此它无法将方法调用“分派”给虚拟的运行时方法。

Go语言规范：选择器里描述了计算x.f表达式（其中f可能是方法）以选择最后要调用的方法时遵循的确切规则。里面的关键点阐述是

• 选择器f可以表示类型T的字段或方法f，或者可以引用T的嵌套匿名字段的字段或方法f。遍历到达f的匿名字段的数量称为其在T中的深度。
• 对于类型T或* T的值x（其中T不是指针或接口类型），x.f表示存在f的T中最浅深度的字段或方法。

回到我们的例子中来就是：

对于Rectangle类型来说si.PrintArea()将调用Shape.PrintArea()因为没有为Rectangle类型定义PrintArea()方法（没有接受者是*Rectangle的PrintArea()方法），而Shape.PrintArea()方法的实现调用的是Shape.Area()而不是Rectangle.Area()-如前面所讨论的，Shape不知道Rectangle的存在。所以会看到输出结果：

Rectangle : Area 0

那么既然在Go里不支持继承，如何以组合解决类似的问题呢。我们可以通过定义参数为ShapeInterface接口的方法定义PrintArea。

func  PrintArea (s ShapeInterface){
    fmt.Printf("Interface => %s : Area %v\r\n", s.GetName(), s.Area())
}

因为并不像例子里的这么简单，后来我的解决方法是定义了一个类似InitShape的方法来完成初始化流程，这里我把ShapeInterface接口和Shape类型做一些调整会更好理解一些。

type ShapeInterface interface {
    Area() float64
    GetName() string
    SetArea(float64)
}
type Shape struct {
    name string
    area float64
}

...
func (s *Shape) SetArea(area float64) {
    s.area = area
}

func (s *Shape) PrintArea() {
    fmt.Printf("%s : Area %v\r\n", s.name, s.area)
}
...

func InitShape(s ShapeInterface) error {
  area, err := s.Area()
  if err != nil {
    return err
  }
  s.SetArea(area)
  ...
}

对于Rectangle和Circle这样的组合Shape的类型，只需要按照自己的计算面积的公式实现Area()，SetArea()会把Area()计算出的面积存储在area字段供后面的程序使用。

type Rectangle struct {
    Shape
    w, h float64
}

func (r *Rectangle) Area() float64 {
    return r.w * r.h
}

r := &Rectangle {
    Shape: Shape{name: "Rectangle"},
    w: 5, 4
}

InitShape(r)
r.PrintArea()

这个案例也是我使用Go写代码以来第一次研究继承和组合的区别，以及怎么用组合的方式在Go语言里复用代码和提供多态的支持。我觉得很多之前用惯面向对象语言的朋友们或多或少都会遇到同样的问题，毕竟思维定式形成后要靠刻意练习才能打破。由于我不能透漏公司代码的设计，所以以这个简单的例子把这部分的使用经验记录下来分享给大家。读者朋友们在用Go语言设计接口和类型时如果遇到类似问题或者有其他疑问可以在文章下面留言，一起讨论。