1. Golang 结构体&方法

对于这一章内容，"匿名字段"用的非常多，它是其声明中只有类型而没有名称的字段，可以以一种很自然的方式为被嵌入的类型带来新的属性和能力。不过，我们需要小心可能产生"屏蔽"现象的地方，尤其是当存在多个嵌入字段或者多层嵌入的时候，"屏蔽"现象可能会让你的实际引用与你的预期不符。另外，你一定要梳理清楚值方法和指针方法的不同之处，包括这两种方法各自能做什么、不能做什么以及会影响到其所属类型的哪些方面。这涉及值的修改、方法集合和接口实现。

1.1. 匿名字段

所谓匿名字段，是指没有名字，仅有类型的字段，被称为嵌入字段或者嵌入类型。

type attr struct {
	perm int
}

type file struct {
	name string
	attr // 仅有类名
}

func main() {
	var f file
	f.name = "lvmenglou"
	f.perm = 24 // 等价于 f.attr.perm = 24
}

1.2. 方法覆盖

usermanagertoString()mtoString()user.toString()m.user.toString()usertoString()

type user struct{}

type manager struct {
	user // 匿名字段
}

func (user) toString() string {
	return "user"
}

func (m manager) toString() string {
	return m.user.toString() + ";manager"
}

func main() {
	var m manager
	println(m.toString())      // 输出：user;manager
	println(m.user.toString()) // 输出：user
}

1.3. 值方法和指针方法

struct

func (ms MyStruct) String() string  // value methods
func (ms *MyStruct) String() string // pointer methods

在官方 effective go 文档中，对两者区别描述如下：

值方法 (value methods) 可以通过指针和值调用，但是指针方法 (pointer methods) 只能通过指针来调用。
但有一个例外，如果某个值是可寻址的 (addressable, 或者说左值）, 那么编译器会在值调用指针方法时自动插入取地址符，使得在此情形下看起来像指针方法也可以通过值来调用。

type Foo struct {
	name string
}

func (f *Foo) PointerMethod() {
	fmt.Println("pointer method on", f.name)
}

func (f Foo) ValueMethod() {
	fmt.Println("value method on", f.name)
}

func NewFoo() Foo { // 返回一个右值，不可寻址
	return Foo{name: "right value struct"}
}

func main() {
	f1 := Foo{name: "value struct"}
	f1.PointerMethod() // 编译器会自动插入取地址符，变为 (&f1).PointerMethod()
	f1.ValueMethod()
	f2 := &Foo{name: "pointer struct"}
	f2.PointerMethod()
	f2.ValueMethod() // 编译器会自动解引用，变为 (*f2).PointerMethod()
	NewFoo().ValueMethod()
	NewFoo().PointerMethod() // Error!!!
}

简而言之，就是不管是普通对象还是指针，都可以调用他们的值方法和指针方法，因为编译器会自行处理，但是对于右值（也就是通过函数返回的临时结构体变量等）, 只能调用值方法，不能调用指针方法。（备注：对于左值和右值的区别，最重要区别就是是否可以被寻址，可以被寻址的是左值，既可以出现在赋值号左边也可以出现在右边；不可以被寻址的即为右值，比如函数返回值、字面值、常量值等等，只能出现在赋值号右边。) 对于某个特定场景，两者如何取舍其实和另一个问题等价：就是你在定义函数时如何传参——是传值还是传指针。比如上述例子：

func (f *Foo) PointerMethod() {
	fmt.Println("pointer method on ", f.name)
}

func (f Foo) ValueMethod() {
	fmt.Println("value method on", f.name)
}

可以转换为下面两个函数进行考虑，用 Go 的术语来说，就是将函数的 receiver 看做是 argument:

func PointerMethod(f *Foo) {
	fmt.Println("pointer method on ", f.name)
}

func ValueMethod(f Foo) {
	fmt.Println("value method on", f.name)
}

在定义 receiver 为值还是指针时，主要有以下几个考虑点：

方法是否需要修改 receiver 本身。如果需要，那 receiver 必然要是指针。
效率问题。如果 receiver 是值，那在方法调用时一定会产生 struct 拷贝，而大对象拷贝代价很大。
一致性。对于同一个 struct 的方法，value method 和 pointer method 混杂用肯定是优雅。

那啥时候用 value method 呢？很简单的不可变对象使用 value method 可以减轻 gc 负担，貌似也就这些好处了。因此请记住：遇事不决请用 pointer method! ! ! 对于第一条，如果需要修改 receiver 本身，必须用指针，我再举个例子：

type N int

func (n N) value() { // value method
	n++
	fmt.Printf("v:%p, %v\n", &n, n)
}

func (n *N) pointer() { // point method
	(*n)++
	fmt.Printf("p:%p, %v\n", n, *n)
}

func main() {
	var a N = 5
	a.value()
	a.pointer()
	fmt.Printf("a:%p,%v\n", &a, a)
}

输出：

v: 0x8200741c8, 26  // 虽然 n 被打印为 26, 但是在 main() 中，n 的值还是 25, 未修改！! ! p: 0x8200741c0, 26 a: 0x8200741c0, 26  // n 的值被修改为 26, 是通过 a.pointer() 修改的！! !

1.4. 方法集

所谓"方法集", 简单来说，就是对于普通类型和指针类型，所包含的方法集合，我们先看个例子：

type S struct{}

type T struct {
	S // 匿名嵌入字段
}

func (S) sVal()  {}
func (*S) sPtr() {}
func (T) sVal()  {}
func (*T) sPtr() {}

func methodSet(a interface{}) {
	t := reflect.TypeOf(a)
	for i, n := 0, t.NumMethod(); i < n; i++ {
		m := t.Method(i)
		fmt.Println(m.Name, m.Type)
	}
}

func main() {
	var t T
	methodSet(t) // 显示 T 方法集
	println("---------------")
	methodSet(&t) // 显示* T 方法集
}

输出：

sVal func(main.T)tVal func(main.T)----------------sPtr func(*main.T)sVal func(*main.T)tPtr func(*main.T)tVal func(*main.T)

值方法值方法指针方法

Treceive T*Treceive T*TSTreceive T*STreceive S*SS*S*Treceive S*S

1.5. 总结

再次强调，嵌入字段是实现类型间组合的一种方式，这与继承没有半点儿关系。Go 语言虽然支持面向对象编程，但是根本就没有"继承"这个概念。最后就是"方法集", 对于普通类型和指针类型，当存在匿名字段时，他们的值方法和指针方法的所属关系，这个是需要掌握的，这里我们没有讨论实际的应用场景，但是当涉及到接口实现和类型转换时，如果对这块知识掌握不够的话，转换会非常容易出现问题，后面在讲接口时，这块会再去讲解。对于方法表达式这块，这块知识不容易和其它知识混淆，也不难掌握，大家可以自行查阅相关资料即可。