来吧,快速搞懂golang接口interface interface是go中一个非常重要的概念，使用的地方非常非常多，有

interface

interface是go中一个非常重要的概念，使用的地方非常非常多，有必要好好学习。

那什么是接口呢？在现实中我们有usb接口、type-c接口、HDMI接口,它们是一种约定,凡是实现了这个约定的电源线，插上就能有对应的功能;

回到go中,go的接口也类似这样,它是一种约定，约定实现了xx方法，那么就实现了该接口。

接口有什么用呢？一句话表述：可以实现多态和灵活的数据类型设计、代码接耦。

1. 接口定义

接口定义非常简单

type 接口名称 interface {
  方法签名
}

2. 多态实现

go是一个强类型语言, 有了接口，我们可以把具有相同功能的对象抽象为一个接口，从而实现多态。

package main

import "fmt"

// 定义一个Speaker接口
type Speaker interface {
	// 这个接口中需要包含一个say方法
	say()
}

type Dog struct{}

// dog实现了Speaker接口
func (d Dog) say() {
	fmt.Println("汪汪汪！")
}

type Cat struct{}

// cat实现了Speaker接口
func (c Cat) say() {
	fmt.Println("喵喵喵")
}

// 对Speaker切片元素调用say方法
func Speak(s []Speaker) {
	for _, sp := range s {
		sp.say() // 多态体现
	}
}

func main() {
	// 初始化一个长度为2的 Speaker接口类型的切片
	s := make([]Speaker, 2)

	s[0] = Cat{}
	s[1] = Dog{}

	Speak(s)
}

// 喵喵喵
// 汪汪汪！

3. 解耦合实现

假设在我们的项目中需要支持多种支付方式，比如微信支付、支付宝支付、银行卡支付，该如何实现呢？

package main

// 支付方式
type PaymentMethod interface {
	// 支付
	Pay(amount float32) error
	// 退款
	Refund(amount float32) error
}

// 支付宝支付
type AliPay struct{}

func (a *AliPay) Pay(amount float32) error {
	// 支付操作
	return nil
}
func (a *AliPay) Refund(amount float32) error {
	// 支付操作
	return nil
}

// 微信支付
type WeixinPay struct{}

func (a *WeixinPay) Pay(amount float32) error {
	// 支付操作
	return nil
}

func (a *WeixinPay) Refund(amount float32) error {
	// 支付操作
	return nil
}

// 操作支付
func DoPay(pm PaymentMethod, amount float32) {
	// 实现于具体支付的接耦
	pm.Pay(amount)
}

func main() {
	pm := &AliPay{}
	DoPay(pm, 100)
}

4. 值接收者和指针接收者

这是一个易错点，需要特别注意哦！

在结构体中，我们知道一个实例不区分值接收者还是指针接收者，都可以正常调用；但是在接口中不是这样的，让我们看下代码：

package main

import "fmt"

// 薪水计算接口
type SalaryCalculator interface {
	calSalary() int
}

// 永久员工
type Permant struct {
	empId       int
	basicPay    int // 基本薪资
	performance int // 绩效
}

// 实现薪水计算接口
func (p *Permant) calSalary() int {
	return p.basicPay + p.performance
}

func main() {
	p := Permant{empId: 1, basicPay: 100, performance: 50}

	// 定义接口类型变量
	var sc SalaryCalculator
	sc = p // 发生错误
	//  cannot use p (variable of type Permant) as SalaryCalculator value in assignment: Permant does not implement SalaryCalculator (method calSalary has pointer receiver)
	fmt.Println(sc.calSalary())
}

在上面的代码中,由于接口中方法实现接收者是指针,所以必须保持接口对象也是指针，否则会报错。

记住下面的规则就行：对于接口而言，当方法是指针接收者时，必须和接收者保持一致（指针），值接收者无所谓

为什么会这样呢？大概是编译器在处理接口类型值转指针时,转换不了。

5. 空接口使用

空接口在go中的使用也是相当的多,主要用做任意类型值的做为参数传入的场景。

interface {}**由于空接口中没有任何方法签名，所以任何类型都实现了空接口.**这也是为什么空接口可以支持任意类型参数传入的原因。

先来看一个示例

package main

import "fmt"

// 打印任何类型的东西
func printAny(v interface{}) {
	fmt.Printf("%#v\n", v)
}

type Person struct {
	name string
}

func main() {
	// 任意类型随便装
	printAny("abc")
	printAny(12)
	printAny(23.54)
	printAny(Person{name: "sd"})
}

// "abc"
// 12
// 23.54
// main.Person{name:"sd"}

6. 类型断言

在上面小结的代码中,我们胡乱的往里面传任意类型的值,虽然代码能运行，但是没啥意义。

在真实的场景中，我们通常需要知道传入的是什么数据类型，并对特定类型做相应的处理，这时候类型断言就派上用场了。

类型断言主要有两种写法：

x.(T) // x是T类型，如果不是，panic
val, ok := x.(T) // 比较安全如果不是 ok为false

我们实践下

package main

import "fmt"

func main() {
	var a interface{}

	a = "hello"             // a当前是一个字符串类型
	fmt.Println(a.(string)) // ok
	// fmt.Println(a.(int))    // not ok 直接报错

	val, ok := a.(string)
	fmt.Printf("val: %#v, ok: %v\n", val, ok)
}

// hello
// val: "hello", ok: true

如果类型很多,上面的ok模式就不太好用,go还提供了一种switch方式，代码如下：

package main

import "fmt"

func main() {
	printAny("abc")
	printAny(float32(1.23))
	printAny(23)
	printAny([]int{1, 2})
}

func printAny(v interface{}) {
	// 注意这里写的是type
	switch val := v.(type) {
	case string:
		// 区分出类型后 再转换成对应类型
		fmt.Printf("这是一个字符串: %s\n", val)
	case float32:
		fmt.Printf("这是一个32位浮点数: %v\n", val)
	case int:
		fmt.Printf("这是一个整型：%v\n", val)
	default:
		fmt.Printf("Unknown type: %v\n", val)
	}
}

// 这是一个字符串: abc
// 这是一个32位浮点数: 1.23
// 这是一个整型：23
// Unknown type: [1 2]

6. 接口本质

接口底层本质是（type,value) 它们是一对的关系，任何一个接口都是由类型和值组成。

7. 空接口与nil值

接口相关的nil值和空指针结构体比较非常容易让人困惑，我们先来看一段代码

package main

import "fmt"

type Person struct{}

func main() {
	var a interface{} // 空接口

	if a == nil {
		fmt.Println("空接口等于nil的哦！")
	}

	var p *Person // 一个指向Person结构体指针
	if p == nil {
		fmt.Println("结构体空指针也等于nil")
	}

	//========= 上面很好理解，关键看下面 ========//
	var b interface{} // 定义一个空接口
	b = p             // 把结构体空指针 赋给空接口

	if b != nil {
		fmt.Println("空结构体指针接口不等于nil")
	}

	if b != a {
		fmt.Println("空结构体指针结构体也不等于空接口")
	}
}

// 空接口等于nil的哦！
// 结构体空指针也等于nil
// 空结构体指针接口不等于nil
// 空结构体指针结构体也不等于空接口

怎么样，对输出有疑惑吧！我们大概总结下，首先，无论对于空接口还是空结构体指针它们都是 == nil的但是,空结构体指针接口，既不等于nil, 也不等于空接口

对这个问题困惑的原因，是因为对接口本质不够理解，接口的内部本质上是由(type,value)一对组成的；

对于空接口，它的类型和值都是nil; 对于空结构体指针接口，它的类型是对应结构体指针类型，值是nil;

所以很容易得出它们不相等。

6. 接口嵌套（组合）

前面我们看到的都是单一接口，接口是支持组合嵌套的，可以由多个单一接口组合成一个其它接口,比如：

// 定义基本接口
type Reader interface {
	Read() string
}

// 在基本接口的基础上定义扩展接口
type ReaderWithInfo interface {
	Reader // 这里嵌套了另外一个接口
	Info() string
}

7. 接口底层实现

接口底层是由两个结构体实现的：

eface e代表empty，即empty interface,没有任何方法的接口
iface 代表包含有方法的接口

type iface struct {
	tab  *itab
	data unsafe.Pointer
}

type eface struct {
	_type *_type
	data  unsafe.Pointer
}

// ita内部有fun用于存储方法
type itab struct {
	inter *interfacetype
	_type *_type
	hash  uint32 // copy of _type.hash. Used for type switches.
	_     [4]byte
	fun   [1]uintptr // variable sized. fun[0]==0 means _type does not implement inter.
}

在这里我们可以看出eface里有type和data，再次映证了,一个接口需要类型和值都为nil才等同于nil；

那么我们应该怎么解决这个问题呢？是反射——只要值是nil就返回true

func isInterfaceValueNil(i interface{}) bool {
    if i == nil {
        return true
    }
    // 使用反射获取接口的动态值
    val := reflect.ValueOf(i)
    // 如果动态值是零值，则返回 true
    return val.Kind() == reflect.Ptr && val.IsNil()
}

来吧,快速搞懂golang接口