方法

认识 Go 方法

• Go 语言从设计伊始，就不支持经典的面向对象语法元素，比如类、对象、继承，等等，但 Go 语言仍保留了名为“方法（method）”的语法元素。当然，Go 语言中的方法和面向对象中的方法并不是一样的。Go 引入方法这一元素，并不是要支持面向对象编程范式，而是 Go 践行组合设计哲学的一种实现层面的需要。
  
  • Go 的方法也是以 func 关键字修饰的，并且和函数一样，也包含方法名（对应函数名）、参数列表、返回值列表与方法体（对应函数体）。
  • 方法中的这几个部分和函数声明中对应的部分，在形式与语义方面都是一致的，比如：方法名字首字母大小写决定该方法是否是导出方法；方法参数列表支持变长参数；方法的返回值列表也支持具名返回值等。
  • 和由五个部分组成的函数声明不同，Go 方法的声明有六个组成部分，多的一个就是图中的 receiver 部分。在 receiver 部分声明的参数，Go 称之为 receiver 参数，这个 receiver 参数也是方法与类型之间的纽带，也是方法与函数的最大不同。
    • Go 中的方法必须是归属于一个类型的，而 receiver 参数的类型就是这个方法归属的类型，或者说这个方法就是这个类型的一个方法。
    • 这里的 receiver 参数 srv 的类型为 *Server，那么我们可以说，这个方法就是 *Server 类型的方法。
    • 每个方法只能有一个 receiver 参数，Go 不支持在方法的 receiver 部分放置包含多个 receiver 参数的参数列表，或者变长 receiver 参数。
    • 方法接收器（receiver）参数、函数 / 方法参数，以及返回值变量对应的作用域范围，都是函数 / 方法体对应的显式代码块。
    • receiver 部分的参数名不能与方法参数列表中的形参名，以及具名返回值中的变量名存在冲突，必须在这个方法的作用域中具有唯一性。
    • 除了 receiver 参数名字要保证唯一外，Go 语言对 receiver 参数的基类型也有约束，那就是 receiver 参数的基类型本身不能为指针类型或接口类型。
    • Go 要求，方法声明要与 receiver 参数的基类型声明放在同一个包内。
      • 我们不能为原生类型（诸如 int、float64、map 等）添加方法。
      • 不能跨越 Go 包为其他包的类型声明新方法。
  • Go 语言中的方法的本质就是，一个以方法的 receiver 参数作为第一个参数的普通函数。

方法集合与如何选择 receiver 类型

receiver 参数类型对 Go 方法的影响

• 我们直接来看下面例子中的两个 Go 方法，以及它们等价转换后的函数：

  func (t T) M1() <=> F1(t T)
  func (t *T) M2() <=> F2(t *T)
  

• 首先，当 receiver 参数的类型为 T 时：
  • 当我们选择以 T 作为 receiver 参数类型时，M1 方法等价转换为F1(t T)。
  • Go 函数的参数采用的是值拷贝传递，也就是说，F1 函数体中的 t 是 T 类型实例的一个副本。
  • 这样，我们在 F1 函数的实现中对参数 t 做任何修改，都只会影响副本，而不会影响到原 T 类型实例。
  • 当我们的方法 M1 采用类型为 T 的 receiver 参数时，代表 T 类型实例的 receiver 参数以值传递方式传递到 M1 方法体中的，实际上是 T 类型实例的副本，M1 方法体中对副本的任何修改操作，都不会影响到原 T 类型实例。
• 第二，当 receiver 参数的类型为 *T 时：
  • 当我们选择以 *T 作为 receiver 参数类型时，M2 方法等价转换为F2(t *T)。
  • 我们传递给 F2 函数的 t 是 T 类型实例的地址，这样 F2 函数体中对参数 t 做的任何修改，都会反映到原 T 类型实例上。
  • 当我们的方法 M2 采用类型为 *T 的 receiver 参数时，代表 *T 类型实例的 receiver 参数以值传递方式传递到 M2 方法体中的，实际上是 T 类型实例的地址，M2 方法体通过该地址可以对原 T 类型实例进行任何修改操作。

选择 receiver 参数类型的原则

• 第一个原则
  • *如果 Go 方法要把对 receiver 参数代表的类型实例的修改，反映到原类型实例上，那么我们应该选择 T 作为 receiver 参数的类型。
  • 无论是 T 类型实例，还是 *T 类型实例，都既可以调用 receiver 为 T 类型的方法，也可以调用 receiver 为 *T 类型的方法。
• 第二个原则
  • 如果我们不需要在方法中对类型实例进行修改呢？这个时候我们是为 receiver 参数选择 T 类型还是 *T 类型呢？
  • 一般情况下，我们通常会为 receiver 参数选择 T 类型，因为这样可以缩窄外部修改类型实例内部状态的“接触面”，也就是尽量少暴露可以修改类型内部状态的方法。
  • *考虑到 Go 方法调用时，receiver 参数是以值拷贝的形式传入方法中的。那么，如果 receiver 参数类型的 size 较大，以值拷贝形式传入就会导致较大的性能开销，这时我们选择 T 作为 receiver 类型可能更好些。
• 第三个原则
  • 方法集合是用来判断一个类型是否实现了某接口类型的唯一手段，可以说，“方法集合决定了接口实现”。
    • Go 中任何一个类型都有属于自己的方法集合，或者说方法集合是 Go 类型的一个“属性”。但不是所有类型都有自己的方法，比如 int 类型就没有。所以，对于没有定义方法的 Go 类型，我们称其拥有空方法集合。
    • 接口类型相对特殊，它只会列出代表接口的方法列表，不会具体定义某个方法，它的方法集合就是它的方法列表中的所有方法，我们可以一目了然地看到。
    • Go 语言规定，*T 类型的方法集合包含所有以 *T 为 receiver 参数类型的方法，以及所有以 T 为 receiver 参数类型的方法。
    • 如果某类型 T 的方法集合与某接口类型的方法集合相同，或者类型 T 的方法集合是接口类型 I 方法集合的超集，那么我们就说这个类型 T 实现了接口 I。
  • 如果 T 类型需要实现某个接口，那我们就要使用 T 作为 receiver 参数的类型，来满足接口类型方法集合中的所有方法。
  • 如果 T 不需要实现某一接口，但 *T 需要实现该接口，那么根据方法集合概念，*T 的方法集合是包含 T 的方法集合的，这样我们在确定 Go 方法的 receiver 的类型时，参考原则一和原则二就可以了。

如何用类型嵌入模拟实现“继承”

什么是类型嵌入

• 类型嵌入指的就是在一个类型的定义中嵌入了其他类型。Go 语言支持两种类型嵌入，分别是接口类型的类型嵌入和结构体类型的类型嵌入。
• 接口类型的类型嵌入
  • 接口类型声明了由一个方法集合代表的接口，比如下面接口类型 E：

    type E interface {
    	M1()
    	M2()
    }
    

    • 这个接口类型 E 的方法集合，包含两个方法，分别是 M1 和 M2，它们组成了 E 这个接口类型所代表的接口。
    • 如果某个类型实现了方法 M1 和 M2，我们就说这个类型实现了 E 所代表的接口。
    • 此时，我们再定义另外一个接口类型 I，它的方法集合中包含了三个方法 M1、M2 和 M3，如下面代码：

      type I interface {
      	M1()
      	M2()
      	M3()
      }
      

    • 接口类型 I 方法集合中的 M1 和 M2，与接口类型 E 的方法集合中的方法完全相同。在这种情况下，我们可以用接口类型 E 替代上面接口类型 I 定义中 M1 和 M2：

      type I interface {
      	EM
      	3()
      }
      

  • 在一个接口类型（I）定义中，嵌入另外一个接口类型（E）的方式，就是接口类型的类型嵌入。
  • 接口类型嵌入的语义就是新接口类型（如接口类型 I）将嵌入的接口类型（如接口类型 E）的方法集合，并入到自己的方法集合中。
• 结构体类型的类型嵌入
  • Go 结构体类型定义有另外一种形式，那就是带有嵌入字段（Embedded Field）的结构体定义。

    type T1 int
    type t2 struct{
    	n int
    	m int
    } 
    type I interface {
    	M1()
    } 
    type S1 struct {
    	T1
    	*t2
    	Ia
    	int
    	b string
    }
    

  • 这种以某个类型名、类型的指针类型名或接口类型名，直接作为结构体字段的方式就叫做结构体的类型嵌入，这些字段也被叫做嵌入字段（Embedded Field）。
  • 如果嵌入类型的名字是首字母大写的，那么也就说明这个嵌入字段是可导出的。

类型嵌入与方法集合

• 嵌入类型的方法集合并入到新接口类型的方法集合中，并且，接口类型只能嵌入接口类型。而结构体类型对嵌入类型的要求就比较宽泛了，可以是任意自定义类型或接口类型。
• 结构体类型的方法集合，包含嵌入的接口类型的方法集合。
• 嵌入了其他类型的结构体类型本身是一个代理，在调用其实例所代理的方法时，Go 会首先查看结构体自身是否实现了该方法。
  • 如果实现了，Go 就会优先使用结构体自己实现的方法。
  • 如果没有实现，那么 Go 就会查找结构体中的嵌入字段的方法集合中，是否包含了这个方法。
  • 如果多个嵌入字段的方法集合中都包含这个方法，那么我们就说方法集合存在交集。
  • 这个时候，Go 编译器就会因无法确定究竟使用哪个方法而报错。
• 结构体类型嵌入接口类型在日常编码中有一个妙用，就是可以简化单元测试的编写。
  • 由于嵌入某接口类型的结构体类型的方法集合包含了这个接口类型的方法集合，这就意味着，这个结构体类型也是它嵌入的接口类型的一个实现。
  • 即便结构体类型自身并没有实现这个接口类型的任意一个方法，也没有关系。
• 在结构体类型中嵌入结构体类型，为 Gopher 们提供了一种“实现继承”的手段，外部的结构体类型 T 可以“继承”嵌入的结构体类型的所有方法的实现。并且，无论是 T 类型的变量实例还是 *T 类型变量实例，都可以调用所有“继承”的方法。
• Go 语言中，凡通过类型声明语法声明的类型都被称为 defined 类型。
  • 对于那些基于接口类型创建的 defined 的接口类型，它们的方法集合与原接口类型的方法集合是一致的。
  • 对于基于非接口类型的 defined 类型创建的非接口类型，基于自定义非接口类型的 defined 类型的方法集合为空的事实，也决定了即便原类型实现了某些接口，基于其创建的 defined 类型也没有“继承”这一隐式关联。也就是说，新 defined 类型要想实现那些接口，仍然需要重新实现接口的所有方法。
• 无论原类型是接口类型还是非接口类型，类型别名都与原类型拥有完全相同的方法集合。