go语言进阶篇——接口
前言
接口是一个非常重要的概念，它描述了一组抽象的规范，但是并不提供具体的实现。对于项目而言可以根据接口使代码可读性更高，使开发更简单，代码风格也会在这期间主键线程规范，这也是我们所推崇的面向接口编程。
接口的概念
接口的定义主要有两种：基本接口与通用接口
- 基本接口：只包含方法集的接口就是方法接口
- 通用接口：只要包含类型集得接口就是方法接口
**备注：**什么是方法集，方法集就是一组方法的集合，同样的，类型集就是一组类型的集合。
基本接口
声明
先来看看接口长什么样子。
type Person interface {
Say(string) string
Walk(int)
}
这是一个Person接口，有两个对外暴露的方法Walk和Say，在接口里，函数的参数名变得不再重要，
初始化
仅仅只有接口是无法被初始化的，因为它仅仅只是一组规范，并没有具体的实现，不过可以被声明。
func main() {
var person Person
fmt.Println(person)
}
输出
实现
我们来看一个简单的情景：
一个建筑公司想一种特殊规格的起重机，于是给出了起重机的特殊规范和图纸，并指明了起重机应该有起重和吊货的功能，建筑公司并不负责造起重机，只是给出了一个规范，这就叫接口，于是公司A接下了订单，根据自家公司的独门技术造出了绝世起重机并交给了建筑公司，建筑公司不在乎是用什么技术实现的，也不在乎什么绝世起重机，只要能够起重和吊货就行，仅仅只是当作一台普通起重机来用，根据规范提供具体的功能，这就叫实现，。只根据接口的规范来使用功能，屏蔽其内部实现，这就叫面向接口编程。过了一段时间，绝世起重机出故障了，公司A也跑路了，于是公司B依据规范造了一台更厉害的巨无霸起重机，由于同样具有起重和吊货的功能，可以与绝世起重机无缝衔接，并不影响建筑进度，建筑得以顺利完成，内部实现改变而功能不变，不影响之前的使用，可以随意替换，这就是面向接口编程的好处。
接下来我们来看一下如何用代码实现上述需求：
package main
import "fmt"
type Boss interface{
Jackup() string
Hoist() string
}
type Company_A struct{
work int //仅以内部数据类型不同来表示不同公司内部细节的不同
}
func (c Company_A) Work(){
fmt.Println("a公司产品开始工作")
}
func (c Company_A) Jackup() string{
c.Work()
return "Jackup"
}
func (c Company_A) Hoist() string{
c.Work()
return "Hoist"
}
type Company_B struct{
boot string //仅以内部数据类型不同来表示不同公司内部细节的不同
}
func (c Company_B) Work(){
fmt.Println("b公司产品开始工作")
}
func (c Company_B) Jackup() string{
c.Work()
return "Jackup"
}
func (c Company_B) Hoist() string{
c.Work()
return "Hoist"
}
type Company struct{
Boss Boss
}
func (c *Company) Bulid(){
fmt.Println("起重功能正在运行中")
fmt.Println("调货功能正在加载中")
}
func main(){
company := Company{Boss: Company_A{}}
company.Bulid()
fmt.Println(company.Boss.Jackup())
fmt.Println(company.Boss.Hoist())
fmt.Println("----------------------")
//切换为b公司产品
company.Boss=Company_B{}
company.Bulid()
fmt.Println(company.Boss.Jackup())
fmt.Println(company.Boss.Hoist())
}
输出为：
起重功能正在运行中
调货功能正在加载中
a公司产品开始工作
Jackup
a公司产品开始工作
Hoist
----------------------
起重功能正在运行中
调货功能正在加载中
b公司产品开始工作
Jackup
b公司产品开始工作
Hoist
上面例子中，可以观察到接口的实现是隐式的，也对应了官方对于基本接口实现的定义：方法集是接口方法集的超集，所以在Go中，实现一个接口不需要implements关键字显式的去指定要实现哪一个接口，只要是实现了一个接口的全部方法，那就是实现了该接口。有了实现之后，就可以初始化接口了，建筑公司结构体内部声明了一个Crane类型的成员变量，可以保存所有实现了Crane接口的值，由于是Crane 类型的变量，所以能够访问到的方法只有JackUp 和Hoist，内部的其他方法例如Work和Boot都无法访问。
之前我们在方法那篇文章中提到任何自定义类型都可以拥有方法，其实对于接口而言，任何自定义类型也可以实现接口，接下来带大家来看两个比较特殊的例子：
type Man interface{
Say(string) string
Walk()string
}
type Person interface{
Man
Play() string
}
这里Man接口方法集是Person的超集，所以Man接口本身也实现了Person接口，这一点大家可以类比继承来理解
type Number int
func (n Number) Say(s string) string {
return "bibibibibi"
}
func (n Number) Walk(i int) {
fmt.Println("can not walk")
}
虽然类型Number的底层类型位int，虽然挺抽象的，但是Number的方法集确实是接口的超集，也算实现这个接口
空接口
type Any interface{
}
Any接口内部没有方法集合，根据实现的定义，所有类型都是Any接口的的实现，因为所有类型的方法集都是空集的超集，所以Any接口可以保存任何类型的值。
func main() {
var anything Any
anything = 1
println(anything)
fmt.Println(anything)
anything = "something"
println(anything)
fmt.Println(anything)
anything = complex(1, 2)
println(anything)
fmt.Println(anything)
anything = 1.2
println(anything)
fmt.Println(anything)
anything = []int{}
println(anything)
fmt.Println(anything)
anything = map[string]int{}
println(anything)
fmt.Println(anything)
}
输出
(0xe63580,0xeb8b08)
1
(0xe63d80,0xeb8c48)
something
(0xe62ac0,0xeb8c58)
(1+2i)
(0xe62e00,0xeb8b00)
1.2
(0xe61a00,0xc0000080d8)
[]
(0xe69720,0xc00007a7b0)
map[]
通过输出会发现，两种输出的结果不一致，其实接口内部可以看成是一个由(val,type)组成的元组，type是具体类型，在调用方法时会去调用具体类型的具体值。
interface{}
这也是一个空接口，不过是一个匿名空接口，在开发时通常会使用匿名空接口来表示接收任何类型的值，例子如下
func main() {
DoSomething(map[int]string{})
}
func DoSomething(anything interface{}) interface{} {
return anything
}
在后续的更新中，官方提出了另一种解决办法，为了方便起见，可以使用any来替代interace{}，两者是完全等价的，因为前者仅仅只是一个类型别名，如下
type any = interface{}
在比较空接口时，会对其底层类型进行比较，如果类型不匹配的话则为false，其次才是值的比较，例如
func main() {
var a interface{}
var b interface{}
a = 1
b = "1"
fmt.Println(a == b)
a = 1
b = 1
fmt.Println(a == b)
}
输出为
false
true
如果底层的类型是不可比较的，那么会panic，对于Go而言，内置数据类型是否可比较的情况如下
| 类型 | 可比较 | 依据 |
|---|---|---|
| 数字类型 | 是 | 值是否相等 |
| 字符串类型 | 是 | 值是否相等 |
| 数组类型 | 是 | 数组的全部元素是否相等 |
| 切片类型 | 否 | 不可比较 |
| 结构体 | 是 | 字段值是否全部相等 |
| map类型 | 否 | 不可比较 |
| 通道 | 是 | 地址是否相等 |
| 指针 | 是 | 指针存储的地址是否相等 |
| 接口 | 是 | 底层所存储的数据是否相等 |
在Go中有一个专门的接口类型用于代表所有可比较类型，即comparable
type comparable interface{ comparable }
提示
如果尝试对不可比较的类型进行比较，则会panic
尾语
关于通用接口的部分，由于它主要的使用还是在泛型中进行使用，所以会在泛型中进行介绍，下一篇就是面向对象的实现了，真的是千呼万唤始出来，下一篇见！