5.1 接口实现
一个接口类型定义了一套方法，如果一个具体类型要实现该接口，那么必须实现接口类型定义中的所有方法。有同学可能觉得，这个概念很简单啊，先看个示例：
type tester interface { test() string() string}type data struct {}func (*data) test() {}func (data) string() string { return ""}func main() { var d data // var t tester = d // 错误：test()不属于data的方法集，所以不支持转换 var t tester = &d // 结构类型是可以直接转换为接口类型 t.test() println(t.string())}
编译器是根据方法集来判断是否实现了接口，显然再上例中只有*data才符合tester的要求，所以不支持var t tester = d的转换，但支持var t tester = &d。可能有同学会觉得这个也和容易，那么当和“嵌入字段”结合起来，这里的转换逻辑可能就比较复杂了，因为只有相同的“方法集”（我再强调一下，方法集必须是包含或者相等关系，比如A必须包含B所有的方法集，A才能赋值给B），才能进行换行，具体的包含关系规则，详见上一章的“方法集”。
5.2 接口组合
接口类型间的嵌入也被称为接口的组合，这个我们很容易联想到结构体类型的嵌入字段，但是两者有很大不同，接口类型间的嵌入要更简单一些，因为它不会涉及方法间的“屏蔽”，只要组合的接口之间有同名的方法就会产生冲突，从而无法通过编译。所以接口体类型组合会存在方法“屏蔽”现象，但是接口不会，这个是两者非常重要的区别！下面我们看一个接口组合的示例：
type stringer interface { string() string}type tester interface { stringer // 嵌入stringer接口 tester()}type data struct {}func (*data) test() {}func (data) string() string { return ""}func pp(a stringer) { // 超级接口变量，可以隐式转换为子集，反过来不行 println(a.string())}func main() { var d data var t tester = &d // *data包含tester所有的方法集，实现了tester接口 pp(t) // 隐式转换为接口子集stringer var s stringer = t // 显示转换为接口子集stringer println(s.string()) // var t2 tester = s // 接口不能逆向转换}
通过上面的示例，我们可以得出一个结论：接口变量可显式/隐式转换为子集，但是不能逆向转换。然后上面的转换过程中，还是绕不开“方法集”的概念，比如写成var t tester = d就不行了，这个概念我再给大家强化一下。
5.3 动态类型
对于一个接口类型的变量来说，我们赋给它的值可以被叫做它的实际值（也称动态值），而该值的类型可以被叫做这个变量的实际类型（也称动态类型）。也就是说，一个接口类型的值（简称为接口值）其实有两个部分：动态类型 + 动态值，下面看一个示例：
type Pet interface { Name() string}type Dog struct { Language() string}type Cat struct { Color() string}func (d Dog) Name() string { return "Dog"}func (d Dog) Language() string { return "汪汪汪"}func (d Cat) Name() string { return "Cat"}func (d Cat) Color() string { return "Black"}func main() { var p pet var dog1 Dog var cat1 Cat pet = dog1 // 动态类型为Dog println(pet.Name()) // 输出：Dog，其实调用的是dog.Name() pet = cat1 // 动态类型为Cat println(pet.Name()) // 输出：Cat，其实调用的是cat.Name() pet = nil // 动态类型和值都是nil}
动态类型这个叫法是相对于静态类型而言的，对于变量pet来讲，它的静态类型就是Pet，并且永远是Pet，但是它的动态类型却会随着我们赋给它的动态值而变化。所以执行pet = dog1时，pet的动态类型为Dog，动态值是dog1的副本；执行pet = cat1时，pet的动态类型为Cat，动态值是cat1的副本。我们可以通过Go语言的这个特性，来实现C++中多态的方法特性，详见下一个小节。
5.4 内嵌接口
我们可以通过结构体内嵌结构体，实现“匿名字段”和“方法覆盖”。也可以通过接口内嵌接口，也就是6.2中的“接口组合”。但是对于结构体内嵌结构的使用，这个可能遇到的比较少:
type Interface interface { Len() int Less(i, j int) bool Swap(i, j int)}type reverse struct { Interface}
大家可能对这用用法比较疑惑，不知道这种方法具体的使用场景是什么？下面我们来看一个完整的例子，以下代码是从sort包提取出来的：
type Interface interface { Len() int Less(i, j int) bool Swap(i, j int)}// Array 实现Interface接口type Array []intfunc (arr Array) Len() int { return len(arr)}func (arr Array) Less(i, j int) bool { return arr[i] < arr[j]}func (arr Array) Swap(i, j int) { arr[i], arr[j] = arr[j], arr[i]}// 匿名接口(anonymous interface)type reverse struct { Interface}// 重写(override)func (r reverse) Less(i, j int) bool { return r.Interface.Less(j, i)}// 构造reverse Interfacefunc Reverse(data Interface) Interface { return &reverse{data}}func main() { arr := Array{1, 2, 3} rarr := Reverse(arr) fmt.Println(arr.Less(0,1)) fmt.Println(rarr.Less(0,1))}
sort包中这么写的目的是为了重写Interface的Less方法，并有效利用了原始的Less方法；通过Reverse可以从Interface构造出一个反向的Interface。go语言利用组合的特性，寥寥几行代码就实现了重写。对比一下传统的组合匿名结构体实现重写的写法，或许可以更好的帮助我们了解匿名接口的优点：
// 同上，全部省略。。。// 匿名structtype reverse struct { Array}// 重写func (r reverse) Less(i, j int) bool { return r.Array.Less(j, i)}// 构造reverse Interfacefunc Reverse(data Array) Interface { return &reverse{data}}func main() { arr := Array{1, 2, 3} rarr := Reverse(arr) fmt.Println(arr.Less(0, 1)) fmt.Println(rarr.Less(0, 1))}
上面这个例子使用了匿名结构体的写法，和之前匿名接口的写法实现了同样的重写功能，甚至非常相似。但是仔细对比一下你就会发现匿名接口的优点，匿名接口的方式不依赖具体实现，可以对任意实现了该接口的类型进行重写。这在写一些公共库时会非常有用，如果你经常看一些库的源码，匿名接口的写法应该会很眼熟。这里我总结结构体内嵌接口的作用：
- 不依赖具体实现：即接口为A，结构体B1、B2实现了接口A，结构体C内嵌了A，那么C.A可以通过B1/B2实例化；
- 对接口类型进行重写：当C.A通过B1实例化后，C和B1的关系，可以转变为接口体C内嵌结构体B1，那么C可以直接使用B1中的所有方法，当然C也可以对B1中的方法进行重写，这里官方文档这样解释“Interface and we can override a specific method without having to define all the others.”
5.5 实现多态的方法
我们先看一个示例：
type IMessage interface { Print()}type BaseMessage struct { //IMessage 没有必要embedding这个interface，因为只是按照契约实现接口，但是并没有利用接口的数据和功能 //一般说来直接实现接口的类都没有必要embedding接口 msg string}func (message *BaseMessage) Print() { fmt.Println("baseMessage:", message.msg)}type SubMessage struct { BaseMessage //因为要使用BaseMessage的数据，所以必须embedding}func (message *SubMessage) Print() { fmt.Println("subMessage:", message.msg)}func interface_use(i IMessage) { i.Print()}func main() { baseMessage := new(BaseMessage) baseMessage.msg = "a" interface_use(baseMessage) // 输出：baseMessage:a SubMessage := new(SubMessage) SubMessage.msg = "b" interface_use(SubMessage) // 输出：subMessage:b}
对于上面代码，看起来可能不难，但是用到的知识点却非常多，我们解读一下：
- 实现接口：结构体BaseMessage，实现了IMessage接口的所有方法；
- 匿名字段嵌入 + 方法覆盖：结构体SubMessage嵌入了BaseMessage，也实现了自己的Print()，所以实际使用时，SubMessage.Print()会覆盖BaseMessage.Print()；
- 接口转换：BaseMessage和SubMessage可以转换为IMessage接口，代码里面是隐式转换；
- 动态类型：BaseMessage和SubMessage都实现了IMessage接口，所以通过隐式转换后，IMessage接口的动态类型和动态值会相应改变，当动态类型为BaseMessage时，执行i.Print()，执行的是BaseMessage.Print()；当动态类型为SubMessage，执行i.Print()，执行的是SubMessage.Print()。
我觉得上面这段代码，其实是Go非常常用的一种方式，会用到Go的常用设计模式中，我们可以通过下一节的示例，再巩固一下。
5.6 实战：设计模式之组合模式
相关内容可以参考：http://tigerb.cn/go-patterns/#/?id=%e7%bb%84%e5%90%88%e6%a8%a1%e5%bc%8f，里面的代码精简如下：
// Context 上下文type Context struct{} // Component 组件接口type Component interface { Mount(c Component, components ...Component) error // 添加一个子组件 Remove(c Component) error // 移除一个子组件 Do(ctx *Context) error // 执行组件&子组件}// BaseComponent 基础组件// 实现Add:添加一个子组件// 实现Remove:移除一个子组件type BaseComponent struct { ChildComponents []Component // 子组件列表}// Mount 挂载一个子组件func (bc *BaseComponent) Mount(c Component, components ...Component) (err error) { bc.ChildComponents = append(bc.ChildComponents, c) if len(components) == 0 { return } bc.ChildComponents = append(bc.ChildComponents, components...) return}// Remove 移除一个子组件func (bc *BaseComponent) Remove(c Component) (err error) { if len(bc.ChildComponents) == 0 { return } for k, childComponent := range bc.ChildComponents { if c == childComponent { fmt.Println(runFuncName(), "移除:", reflect.TypeOf(childComponent)) bc.ChildComponents = append(bc.ChildComponents[:k], bc.ChildComponents[k+1:]...) } } return}// Do 执行组件&子组件func (bc *BaseComponent) Do(ctx *Context) (err error) { // do nothing return}// ChildsDo 执行子组件func (bc *BaseComponent) ChildsDo(ctx *Context) (err error) { // 执行子组件 for _, childComponent := range bc.ChildComponents { if err = childComponent.Do(ctx); err != nil { return err } } return} // CheckoutPageComponent 订单结算页面组件type CheckoutPageComponent struct { // 合成复用基础组件 BaseComponent}// Do 执行组件&子组件func (bc *CheckoutPageComponent) Do(ctx *Context) (err error) { // 当前组件的业务逻辑写这 fmt.Println(runFuncName(), "订单结算页面组件...") // 执行子组件 bc.ChildsDo(ctx) // 当前组件的业务逻辑写这 return}// AddressComponent 地址组件type AddressComponent struct { BaseComponent}func (bc *AddressComponent) Do(ctx *Context) (err error) { fmt.Println(runFuncName(), "地址组件...") bc.ChildsDo(ctx) return}// StoreComponent 店铺组件type StoreComponent struct { BaseComponent}func (bc *StoreComponent) Do(ctx *Context) (err error) { fmt.Println(runFuncName(), "店铺组件...") bc.ChildsDo(ctx) return}// SkuComponent 商品组件type SkuComponent struct { BaseComponent}func (bc *SkuComponent) Do(ctx *Context) (err error) { fmt.Println(runFuncName(), "商品组件...") bc.ChildsDo(ctx) return}// PromotionComponent 优惠信息组件type PromotionComponent struct { BaseComponent}func (bc *PromotionComponent) Do(ctx *Context) (err error) { fmt.Println(runFuncName(), "优惠信息组件...") bc.ChildsDo(ctx) return}// ExpressComponent 物流组件type ExpressComponent struct { BaseComponent}func (bc *ExpressComponent) Do(ctx *Context) (err error) { fmt.Println(runFuncName(), "物流组件...") bc.ChildsDo(ctx) return}// AftersaleComponent 售后组件type AftersaleComponent struct { BaseComponent}func (bc *AftersaleComponent) Do(ctx *Context) (err error) { fmt.Println(runFuncName(), "售后组件...") bc.ChildsDo(ctx) return}func main() { // 初始化订单结算页面 这个大组件 checkoutPage := &CheckoutPageComponent{} // 挂载子组件 storeComponent := &StoreComponent{} skuComponent := &SkuComponent{} skuComponent.Mount( &PromotionComponent{}, &AftersaleComponent{}, ) storeComponent.Mount( skuComponent, &ExpressComponent{}, ) // 挂载组件 checkoutPage.Mount( &AddressComponent{}, storeComponent, ) // 开始构建页面组件数据 checkoutPage.Do(&Context{})}
这里其实不是为了去讲设计模式，主要是希望能借鉴这个示例，来巩固上面的知识，里面的代码细节，我就不再给大家剖析了，等后面有时间，我再把这个示例的前因后果，整体再讲一下。
5.7 实战：设计模式之工厂 + 策略模式
type Pool interface { Get() (io.Closer, error) Put(obj io.Closer) Close() error}// 工厂方法func NewPool(type, name string, size int, newFunc func() (io.Closer, error)) Pool { if type == "chanPool" { return NewChanPool(name, size, newFunc) } else { return NewRingBufferPool(name, size, newFunc) }} // type chanPool struct { name string size int idle int32 max int32 ch chan io.Closer new func() (io.Closer, error)}func NewChanPool(name string, size int, newFunc func() (io.Closer, error)) Pool { return &chanPool{ name: name, size: size, ch: make(chan io.Closer, size), new: newFunc, }}// 假如实现了Pool接口，实现方法省略。。。 type ringBufferPool struct { sync.Once err error closed int32 name string rb *RingBuffer new func() (io.Closer, error)}func NewRingBufferPool(name string, size int, newFunc func() (io.Closer, error)) Pool { return &ringBufferPool{ err: errors.New("failed get object from ring buffer pool " + name), name: name, rb: NewRingBuffer(int32(size)), new: newFunc, }}// 实现了Pool接口，实现方法省略。。。 func main() { var pool pool := NewPool("chanPool", "testpool", 10, nil) pool.Close() // 调用的是chanPool的Close方法 pool := NewPool("ringBufferPool", "testpool", 10, nil) pool.Close() // 调用的是ringBufferPool的Close方法}
这个示例，就当给大家额外学习，本来是不打算写在这里面的。实例化了2个结构体，分别为chanPool和ringBufferPoo，隐式转换为接口pool后，可以通过pool中的方法，动态调用实例化对象的方法。
5.8 总结
接口这块知识，其实在我没有完全梳理完之前，总感觉有些知识点比较模糊，当碰到比较复杂的代码，就有种没有摸透的感觉，现在将它们全部梳理完后，感觉里面的语法就清晰了很多。对于接口实现，如果大家对方法集不是特别清楚，这里其实是很容易入坑的，因为是否实现了该接口，编译器是根据方法集来判断的。然后就是接口组合，之前知道接口体有匿名字段，可以进行组合，这里又搞个接口组合，就有点迷糊了，其实两者有异曲同工，重要的区分就是接口组合是没有屏蔽的概念，如果定义相同的接口方法，编译器会直接报错的。对于动态类型，这个可能是接口中稍微比较复杂的地方，我们要弄清楚的是，接口变量的动态值、动态类型都代表了什么，这些其实都是正确使用接口变量的基础。最后通过“实现多态的方法”和“设计模式之组合模式”两小节，将结构体、方法、匿名字段、动态类型、方法屏蔽、隐式转换等知识全部串起来，这些知识虽然看起来比较零散（很多书籍讲述这些知识时，也都是零散的去讲，有的甚至完全没有去讲，所以一直不能将这些知识点系统的串起来，这个也是我想写这个手册的初衷之一），但是他们直接其实有着千世万缕的联系。最后，对于结构体内嵌结构体，结构体内嵌接口，然后一些常用专有名词的理解和设计模式的运用，我画个大图，大家可以一目了然。
