Go中的interface学习

学过Java的同学都知道在Java中接口更像是一种规范，用接口定义了一组方法，下面实现这个接口的类只管按照写好的方法名和返回值去实现就好，内部如何实现是各个方法自己的事情，接口本身不关注。

另外Java中实现接口的类必须显式的声明实现了哪个接口： implement InterfaceName,仔细思考一下会有如下问题:

1. 如果你修改了接口名，那么类也得跟着修改；
2. 你必须先定义接口，才能去实现它；
3. 一个类可以实现多个接口，Java中接口的设计更像是弥补继承的不足，如果你希望实现类再实现一个接口，那么的继续修改实现类。

带着以上几个问题，我们先看Go中如何去使用Interface，再去探讨理论的问题。

1.定义interface

在Go中接口是用type关键字定义，所以可以说interface是一种具有一组方法的类型，这些方法定义了interface的行为。当然，更突出的是Go允许不带任何方法的interface，这种类型的interface叫做empty interface。

下面的例子展示一个结构体实现了两个接口，但是一眼看上去你无法得知他实现了哪两个接口。

type Person interface {
 GetAge() int
 GetName() string
}

type Car interface {
 GetAge() int
 GetName() string
}

type Student struct {
 age int
 name string
}

func (s Student) GetAge() int {
 return s.age
}

func (s Student) GetName() string {
 return s.name
}

上面有两个接口Person,Car。Stuent结构体有两个方法和这两个结构体中的方法一样，这就表示Student实现两这两个接口，当然你可以试一下将其中的一个方法注释掉。如果你用的GoLand 编辑器，你会发现编辑器左边的Student身上带着的上限的绿色箭头消失了，表示当前结构体没有实现任何方法。

综上：接口中有几个方法，实现者必须完全实现这些方法才表示当前实现的结构体或者自定义类型实现了这个接口。这一点跟Java中并无区别。

另外你是否也发现，其实你可以先去实现方法，在定义接口，因为接口跟实现之间完全没有耦合关系，接口是根据适用方的需求来定义的，完全不必要关心是否有其他地方定义过。

2.使用interface

先来看如下一段代码：

package main

import "fmt"

type Get interface {
	Get_name() string
}

type Person struct {
	age int16
	name string
}

type Student struct {
	no int16
	name string
}

func (p Person) Get_name() string {
	return p.name
}

func (s Student) Get_name() string {
	return s.name
}

func Get_name(get Get) string {
	return get.Get_name()
}


func main() {
	s := Student{12345,"xiaoming"}
	name := Get_name(s)
	fmt.Println(name)
}

上面定义了一个接口Get,分别定义了两个结构体都去实现了这个接口，那么如何去通过接口帮我们隐藏当前调用的哪个具体的实现呢，关键就在Get_name方法，这个方法的参数是接口本身，里面的实现你可以通过接口去调用他的任何方法，这些调用目前为止跟任何实现没有任何关系。

注意到下面我们在main方法中定义了一个Student类型的对象s，然后将s传入Get_name方法中，这就表示当前接口的实现者是Student，那么他走的就是Student相关的实现逻辑。即当前Get接口类型的变量get存储的是一个Student对象。

3. 如何判断 interface 变量存储的是哪种类型

现实开发中可能会有一种需求：因为Get_name是每个实现者自己去实现的方法，那么如果想在Get_name方法外面加点料，即需要判断当前来的实现者是哪种类型然后针对某种类型的实现者加点料，该如何做呢。

func Get_name(get Get) string {
	switch get.(type) {
	case Person:
		fmt.Println("person")
	case Student:
		fmt.Println("student")
	}
	return get.Get_name()
}

注意：interface.(type)方法只能在switch中实现，出了switch方法你就不能用.的方式调出来这个方法了。

.(type)表示当前我们要断言的类型。

4. 空的interface

interface{} 是一个空的 interface 类型，根据前文的定义：一个类型如果实现了一个 interface 的所有方法就说该类型实现了这个 interface，空的 interface 没有方法，所以可以认为所有的类型都实现了 interface{}。如果定义一个函数参数是 interface{} 类型，这个函数应该可以接受任何类型作为它的参数。

func doAnything(i interface{}){
    
}

这是一个很重要的特性。

4.1 使用空interface作为返回参数接收任一类型返回值

我们来看下面这个例子：

type BaseInfo struct{
	userId int
	userName string
}

type StudentInfo struct{
	BaseInfo
	Options []string
}

type StaffInfo struct{
	StudentInfo
	cardId string
}

func checkData(id int) (interface{} , bool) {
	data1 ,ok1 := CheckStaffData(id) // 检查员工信息是否正确，返回StaffInfo
	data2 ,ok2 := CheckStudentData(id)  // 检查学生信息是否正确，返回StudentInfo

	if ok1 {
		return data1,ok1
	}

	if ok2 {
		return data2,ok2
	}

	return nil ,false
}

在checkData方法中我们使用了接口作为第一个返回值的接收参数。任何类型都可以。那么下一个问题来了，我们如何去解析用接口接收的这个返回吹呢？还记得上面用 switch interface.(type)判断的例子吧，所以代码可以这样写：

func getData()  {
	if data,ok := fetchQuestion(22); ok {
		switch data.(type) {
		case StaffInfo:
			fmt.Println("staffInfo")
		case StudentInfo:
			fmt.Println("student")
		case A:
			fmt.Println("A")
		case B:
			fmt.Println("B")
			...
			...
			...
		}
			
	}
	
}

有没有发现这个switch很有可能会成为巨无霸。

在Java中是如何解决这个问题的呢？Java提供了继承和接口的方法，通过定义一个抽象类，或者一个接口，让每一个case的逻辑去实现这个抽象类或者接口，使用工厂模式去加载需要的实现类即可。每次有变动我们只用去更改工厂类，新增新的实现，getData方法可以不用变动。

那么在Go中如何实现呢？

type InfoType interface {
	getType() int
	getData(s string)
}

type BaseInfo struct{
	userId int
	userName string
	returnType int8
}

type StudentInfo struct{
	BaseInfo
	Options []string
}

type StaffInfo struct{
	StudentInfo
	cardId string
}

func (b BaseInfo) getType() int8 {
	return b.returnType
}

func (b BaseInfo) getData(s string)  {
	b.getData(s)
}

func fetchQuestion(id int) (InfoType , bool) {
	data1 ,ok1 := CheckStaffData(id) // 检查员工信息是否正确，返回StaffInfo
	data2 ,ok2 := CheckStudentData(id)  // 检查学生信息是否正确，返回StudentInfo

	if ok1 {
		return data1,ok1
	}

	if ok2 {
		return data2,ok2
	}

	return nil ,false
}




func getData()  {
	var s string
	if data,ok := fetchQuestion(22); ok {
		switch data.getType() {
		case A:
			s = A
		case B:
			s = B
		case C:
			s = C
		}
		data.getData(s)
	}

}

在上面代码中，把人员类型抽象成了一个接口，定义了两个方法：

• 获取类型；
• 根据类型选择不同的实现；

BaseInfo和StudentInfo可以分别去实现这个接口。

最关键的是getData方法的修改，case中只用对type赋值即可，最后由getData方法根据type去调用不同的实现。简化了操作。

5. []interface{}的使用

上面刚说interface{}作为参数陈可以承接任何类型，那么[]interface{}作为参数是不是也可以承接任何类型的数组呢？先来试验一下。

package main

import (
"fmt"
)

func getAll(vals []interface{}) {
	for _, val := range vals {
		fmt.Println(val)
	}
}

func main() {
	names := []string{"a", "b", "b"}
	getAll(names)
}

如果你用的是GoLand，你会发现检查就报错，还没到编译期。

interface{}可以表示任一类型，不表示[]interface{}可以表示任意类型的数组，它只是表示这是一个数组，里面你想装啥都可以。

正确的使用[]interface{}的姿势是这样的，你需要new 一个interface类型的数组对象，将想要的元素塞进这个数组就可以。

package main

import (
"fmt"
)

func getAll(vals []interface{}) {
	for _, val := range vals {
		fmt.Println(val)
	}
}

func main() {
	names := []string{"a", "b", "b"}
	c := 3
	v := make([]interface{},4)
	for i,value :=range names {
		v[i] = value
	}
	v[3] = c
	getAll(v)

	fmt.Println(v)
}