Golang中匿名组合实现伪继承的方法

"go语言的面向对象机制与一般语言不同。 它没有类层次结构， 甚至可以说没有类； 仅仅通过组合（ 而不是继承） 简单的对象来构建复杂的对象。" -- 《go语言圣经》

1.匿名组合

1.1 匿名组合定义

golang中组合语法，就是在一个类中，引入了另一个类，如

  type logger struct{
  }
  type work struct{
    log logger
  }
  type work2 struct{
    log *logger
  }

  func (logger)info(v ...interface{}){
  }

如上边代码所示，work类中定义了一个logger类型的变量，这种是比较常见的引入方式，姑且在此称之为非匿名组合，那什么是匿名组合呢，如其名，就是在组合的过程中，不给名字呗，如代码所示：

type logger struct {
}
type work struct {
  logger
}
type work2 struct {
  *logger
}

func (logger) info(v ...interface{}) {
}

上边的代码中，work类与work2类均与logger类匿名组合。两个类唯一不同的是，work2中组合的是指针类型的logger类。

1.2 组合对象初始化

非匿名组合初始化方式

func main(){
  var wk = work{log:logger{}}
  var wwk = work{logger{}}
  //...and so on

  var wk2 = work2{log:new(logger)}
  var wwk2 = work2{new(logger)}
  //... and so on
}

匿名组合初始化

func main(){
  var wk = work{logger{}}
  var wwk = work{logger:logger{}}
  //... and so on
  var wk2 = work2{new(logger)}
  var wwk2 = work2{logger:&logger{}}
  //... and so on
}

上边是匿名组合常见的初始化方式。匿名组合后，被包含类得方法和属性可以直接被使用，即使是私有变量。

注意事项：

1.匿名组合多个类时，不同的类存在相同的方法，会不会冲突？答案是，不同的类中，不同的方法时不会冲突的，但是在调用这个方法时，需要明确是那个类中的方法，如果匿名组合进来的类得方法，与这个类主体中的方法发生冲突，那么默认情况下，会使用主体类中的方法。

2.匿名组合多个类时，类名相同，会不会冲突？答案是，会。就算包名不同，类名相同，也会冲突。

示例代码：

package main
import(
  "bufio"
)
type reader struct {
}
type work4 struct {
  reader
  bufio.reader
}

上边代码编译时，会提示reader重复定义 duplicate field reader

原因在于，匿名组合中，没有给引入的类命名，所以默认采用了类名作为属性名。如上边wwk2这个对象在调用logger的info方法时，可以采用wwk2.info(“hello”)，也可以采用wwk2.logger.info(“hello”).

下边附上一段完整的演示代码，注意会报错哦，这段代码包含了上边的duplicate field reader错误：

package main

import (
  "bufio"
  "fmt"
)

type logger struct {
}

type work struct {
  logger
}

type work2 struct {
  *logger
}
type work3 struct {
  log *logger
}

type reader struct {
}
type work4 struct {
  reader
  bufio.reader
}

func (logger) info(v ...interface{}) {
  fmt.println(v...)
}

func main() {
  var wk = work{logger{}}
  wk.info("hello: work{logger{}}")
  var wwk = work{logger: logger{}}
  wwk.info("hello: work{logger: logger{}}")
  //... and so on
  var wk2 = work2{new(logger)}
  wk2.info("hello: work2{new(logger)}")
  var wwk2 = work2{logger: &logger{}}
  wwk2.info("hello: work2{logger: &logger{}}")
  wwk2.logger.info("hello: wwk2.logger.info")

  var wk3 = work3{new(logger)}
  wk3.log.info("hello: work3{new(logger)}")
}

3. 结构体嵌入和匿名成员

go语言提供别样的 结构体嵌入 机制，让一个结构体包含另一个结构体类型的 匿名成员 ， 这样就可以通过简单的点运算符x.f来访问匿名成员链中嵌套的x.d.e.f成员。

go语言有一个特性让我们只声明一个成员对应的数据类型而不指名成员的名字； 这类成员就叫匿名成员。 匿名成员的数据类型必须是命名的（而不是匿名的）类型或指向一个命名的类型的指针。

type circle struct {
 point
 radius int
} 

type wheel struct {
 circle
 spokes int
}

由于有了匿名嵌入的特性， 我们可以直接访问内嵌类型的成员变量而不需要给出完整的路径：

var w wheel
w.x = 8 // 等价于 w.circle.point.x = 8
w.y = 8 // 等价于 w.circle.point.y = 8
w.radius = 5 // 等价于 w.circle.radius = 5
w.spokes = 20

同样的规则，内嵌类型的方法也会提升为外部类型的方法。

3.1 匿名冲突(duplicate field)

匿名成员也有一个隐式的名字，以其类型名称（去掉包名部分）作为成员变量的名字。 因此不能同一级同时包含两个类型相同的匿名成员， 这会导致名字冲突。

type logger struct {
  level int
}

type myjob struct {
  *logger
  name string
  *log.logger // duplicate field logger
}

4. 匿名组合不是继承

4.1 方法的接受者没变

当我们嵌入一个类型，这个类型的方法就变成了外部类型的方法，但是当它被调用时，方法的接受者是内部类型(嵌入类型)，而非外部类型。— effective go

type job struct {
 command string
 *log.logger
}

func (job *job)start() {
 job.log("starting now...")
 ... // 做一些事情
 job.log("started.")
}

上面这个job例子，即使组合后调用的方式变成了job.log(...)，但log函数的接收者仍然是 log.logger指针，因此在log中也不可能访问到job的其他成员方法和变量。

4.1 内嵌类型不是基类

如果读者对基于 类 来实现的面向对象语言比较熟悉的话， 可能会倾向于将 内嵌类型 看作一个基类， 而 外部类型 看作其子类或者继承类， 或者将 外部类型 看作 "is a" 内嵌类型 。 但这样理解是错误的。

type point struct{ x, y float64 }

type coloredpoint struct {
 point
 color color.rgba
}

func (p point) distance(q point) float64 {
 dx := q.x - p.x
 dy := q.y - p.y
 return math.sqrt(dx*dx + dy*dy)
}

请注意上面例子中对distance方法的调用。 distance有一个参数是point类型， 但q并不是一个point类， 所以尽管q有着point这个内嵌类型， 我们也必须要显式地选择它。 尝试直接传q的话你会看到错误：

red := color.rgba{255, 0, 0, 255}
blue := color.rgba{0, 0, 255, 255}
var p = coloredpoint{point{1, 1}, red}
var q = coloredpoint{point{5, 4}, blue}
fmt.println(p.distance(q.point)) // "5"

p.distance(q) // compile error: cannot use q (coloredpoint) as point

一个coloredpoint并不是一个point， 但coloredpoint "has a" point， 并且它有从point类里引入的 distance方法。

实际上，从实现的角度来考虑问题， 内嵌字段会指导编译器去生成额外的包装方法来委托已经声明好的方法， 和下面的形式是等价的：

func (p coloredpoint) distance(q point) float64 {
 return p.point.distance(q)
}

当point.distance被以上编译器生成的包装方法调用时， 它的接收器值是p.point， 而不是p。

4.3 匿名冲突(duplicate field) 和隐式名字

匿名成员也有一个隐式的名字，以其类型名称（去掉包名部分）作为成员变量的名字。 因此不能同一级同时包含两个类型相同的匿名成员， 这会导致名字冲突。

type logger struct {
level int
}

type myjob struct {
*logger
name string
*log.logger // duplicate field logger
}

以下两点都间接说明匿名组合不是继承：

• 匿名成员有隐式的名字
• 匿名可能冲突(duplicate field)

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。