GO语言中的接口（interface）
1、什么是接口（interface）？
在Go语言中，接口（interface）是方法的集合，它允许我们定义一组方法但不实现它们，任何类型只要实现了这些方法，就被认为是实现了该接口。
接口更重要的作用在于多态实现，它允许程序以多态的方式处理不同类型的值。接口体现了程序设计的多态和高内聚、低耦合的思想。
package main
import "fmt"
// 定义接口
type Person interface {
GetName() string
GetAge() int
}
// 定义结构体
type Student struct {
Name string
Age int
}
// 实现接口
// 实现 GetName 方法
func (s Student) GetName() string {
fmt.Println("name:", s.Name)
return s.Name
}
// 实现 GetAge 方法
func (s Student) GetAge() int {
fmt.Println("age:", s.Age)
return s.Age
}
// 使用接口
func main() {
var per Person
var stu Student
stu.Name = "xiaozhang"
stu.Age = 24
per = stu
per.GetName() // name: xiaozhang
per.GetAge() // age: 24
}
2、注意事项
（1）接口本身不能创建实例，但是可以指向一个实现了该接口的自定义类型的变量（实例）。
（2）接口中所有的方法都没有方法体，即都是没有实现的方法。
（3）在Go中，一个自定义类型需要将某个接口的所有方法都实现，才能说这个自定义类型实现了该接口。
（4）一个自定义类型只有实现了某个接口，才能将该自定义类型的实例（变量）赋给接口类型。
（5）只要是自定义数据类型就可以实现接口，不仅仅是结构体类型（structs），还包括类型别名（type aliases）、其他接口、自定义类型、变量等。
（6）一个自定义类型可以实现多个接口。
（7）interface 接口不能包含任何变量。
（8）一个接口可以继承多个别的接口，这时如果要实现这个接口必须实现它继承的所有接口的方法。在低版本的Go编辑器中，一个接口继承其他多个接口时，不允许继承的接口有相同的方法名。比如A接口继承B、C接口，B、C接口的方法名不能一样。高版本的Go编辑器没有相关问题。
（9）interface类型默认是一个指针（引用类型），如果没有对interface初始化就使用，那么会输出nil。
var i interface{}
fmt.Println(i == nil) // 输出：true
（10）在Go中，接口的实现是非侵入式，隐式的，不需要显式声明“我实现了这个接口”。只要一个类型提供了接口中定义的所有方法的具体实现，它就自动成为该接口的一个实现者。
（11）空接口interface{}没有任何方法，是一个能装入任意数量、任意数据类型的数据容器，我们可以把任何一个变量赋给空接口类型。任意数据类型都能实现空接口，这就和 “空集能被任意集合包含” 一样，空接口能被任意数据类型实现。
3、interface底层实现
Go的interface源码在Golang源码的runtime目录中。Go的interface是由两种类型来实现的：iface和eface。runtime.iface表示非空接口类型，runtime.eface表示空接口类型interface{}。
iface是包含方法的interface，如：
type Person interface {
GetName()
}
eface是不包含方法的interface，即空interface，如：
type Person interface {
}
//或者
var person interface{} = xxxx实体
iface的源代码是：
type iface struct {
tab *itab // 表示值的具体类型的类型描述符
data unsafe.Pointer // 指向值的指针（实际的数据）
}
itab是iface不同于eface的关键数据结构。其包含两部分：一部分是唯一确定包含该interface的具体结构类型，一部分是指向具体方法集的指针。
4、侵入式与非侵入式
GO语言的接口是非侵入式接口。
- 侵入式
侵入式接口的实现是显式声明的，必须显式的表明我要继承那个接口，必须通过特定的关键字（如Java中的implements）来声明实现关系。
优点：通过侵入代码与你的代码结合可以更好的利用侵入代码提供给的功能。
缺点：框架外代码就不能使用了，不利于代码复用。依赖太多重构代码太痛苦了。
- 非侵入式
非侵入式接口的实现是隐式声明的，不需要通过任何关键字声明类型与接口之间的实现关系。只要一个类型实现了接口的所有方法，那么这个类型就实现了这个接口。
优点：代码可复用，方便移植。非侵入式也体现了代码的设计原则：高内聚，低耦合。
缺点：无法复用框架提供的代码和功能。
侵入式接口存在的问题：
（1）侵入式接口把实现类与具体接口绑定起来了，强耦合;
（2）假如修改了接口方法，则实现类方法必须改动；
（3）假如类想再实现一个接口，类方法也必须进行改动；
（4）后续实现此接口的类，必须了解相关的接口；
Go语言非侵入式的方式很好地解决了这几个问题，只要实现了与接口相同的方法，就实现了这个接口。随着代码量的增加，根本不需要关心实现了哪些接口，不需要刻意去先定义接口再实现接口，在原有类里新增实现接口时，不需要更改类，做到低侵入式、低耦合开发。
go语言中非侵入式接口的影响：
1、go语言标准库不再需要绘制类库的继承树。
2、实现类的时候，只需要关心自己应该提供哪些方法，不用再纠结接口需要拆得多细才合理。
3、接口由使用方按自身需求来定义，使用方无需关心是否有其他模块定义过类似的接口。
5、接口的应用场景
Go接口的应用场景包括多态性、解耦、扩展性、代码复用、API设计、单元测试、插件系统、依赖注入。
多态性：接口使得代码可以更加灵活地处理不同类型的数据。通过接口，可以编写更加通用的代码，而无需关心具体的数据类型。
解耦：通过接口将代码模块解耦，降低模块之间的耦合度。不同模块只需要遵循同一个接口，即可实现模块间的无缝整合。这样，当一个模块的实现发生变化时，其他模块不需要做出相应的修改。
扩展性：通过接口，可以轻松地为现有的类型添加新的功能，只需实现相应的接口，而无需修改原有的代码。这种方式使得代码更容易扩展和维护。
代码复用：接口提供了一种将相似行为抽象出来并进行复用的方式，从而减少了代码的重复性。这样，可以更加高效地编写和维护代码。
API设计：通过定义接口，可以规范API的输入和输出，提高代码的可读性和可维护性。
单元测试：通过使用接口，可以轻松地替换被测试对象的实现，从而实现对被测代码的独立测试。
插件系统：通过定义一组接口，不同的插件可以实现这些接口，并在程序运行时动态加载和使用插件。
依赖注入：通过定义接口，可以将依赖对象的创建和管理交给外部容器，从而实现松耦合的代码结构。
- 类型转换。可将接口变量还原为原始类型，或用来判断是否实现了某个更具体的接口类型。
var s int
var x interface
x = s
y , ok := x.(int)
//将interface 转为int,ok可省略 但是省略以后转换失败会报错，
//true转换成功，false转换失败, 并采用默认值
- 类型判断。用switch语句在多种类型间做出推断匹配，这样空接口就有更多发挥空间。
var x interface
switch val.(type) {
case nil:
fmt.Println("nil")
case string:
fmt.Println("type is string, ", val)
case bool:
fmt.Println("type is bool, ", val)
case int:
fmt.Println("type is int, ", val)
case float32, float64:
fmt.Println("type is float, ", val)
default:
fmt.Println("unknown")
}
- 实现多态功能。根据对象的实际定义来实现不同的行为，从而实现多态行为。
// 多态
package main
import "fmt"
// Shape 接口定义了一个计算面积的方法
type Shape interface {
Area() float64
}
// Rectangle 结构体实现了 Shape 接口
type Rectangle struct {
Width, Height float64
}
func (r Rectangle) Area() float64 {
return r.Width * r.Height
}
// Circle 结构体实现了 Shape 接口
type Circle struct {
Radius float64
}
func (c Circle) Area() float64 {
return math.Pi * c.Radius * c.Radius
}
// DescribeShape 接受 Shape 接口类型的参数，输出图形的面积
func DescribeShape(s Shape) {
fmt.Printf("Shape Area: %.2f\n", s.Area())
}
func main() {
r := Rectangle{Width: 3, Height: 4}
c := Circle{Radius: 5}
// 计算不同图形的面积
DescribeShape(r) // Shape Area: 12.00
DescribeShape(c) // Shape Area: 78.54
}
- 作为函数参数或返回值。不推荐作为函数的返回值，代码的维护、拓展与重构将会变得极为痛苦。
package main
import "fmt"
func GetType(val interface{}) {
switch val.(type) {
case nil:
fmt.Println("nil")
case string:
fmt.Println("type is string, ", val)
case bool:
fmt.Println("type is bool, ", val)
case int:
fmt.Println("type is int, ", val)
case float32, float64:
fmt.Println("type is float, ", val)
default:
fmt.Println("unknown")
}
}
func main() {
GetType(3) // type is int, 3
GetType("interface") // type is string, interface
GetType(3.01) // type is float, 3.01
}
空接口的应用场景
（1）用空接口可以让函数和方法接受任意类型、任意数量的函数参数，空接口切片还可以用于函数的可选参数。
（2）空接口还可以作为函数的返回值，但是极不推荐这样干，因为代码的维护、拓展与重构将会变得极为痛苦。
（3）空接口可以实现保存任意类型值的字典 (map)。
6、其他使用
- interface接口嵌套
// 接口嵌套
package main
import "fmt"
// 定义接口
type Person interface {
GetName() string
GetAge() int
}
// 接口嵌套
type Test interface {
GetSex() string
Person // 继承Person
}
type Student struct {
Name string
Age int
}
type Teacher struct {
Name string
Age int
Sex string
}
// 实现 GetName 方法
func (s Student) GetName() string {
fmt.Println("name:", s.Name)
return s.Name
}
// 实现 GetAge 方法
func (s Student) GetAge() int {
fmt.Println("age:", s.Age)
return s.Age
}
// 实现 GetName 方法
func (t Teacher) GetName() string {
fmt.Println("name:", t.Name)
return t.Name
}
// 实现 GetAge 方法
func (t Teacher) GetAge() int {
fmt.Println("age:", t.Age)
return t.Age
}
// 实现 GetSex 方法
func (t Teacher) GetSex() string {
fmt.Println("sex:", t.Sex)
return t.Sex
}
func main() {
var per Person
var stu Student
var tea Teacher
stu.Name = "xiaozhang"
stu.Age = 24
tea.Name = "lilaoshi"
tea.Age = 40
tea.Sex = "man"
per = stu
per.GetName() // name: xiaozhang
per.GetAge() // age: 24
per = tea
per.GetName() // name: lilaoshi
per.GetAge() // age: 40
var test Test
test = tea
test.GetName() // name: lilaoshi
test.GetAge() // age: 40
test.GetSex() // sex: man
}
- interface 接口组合
// 接口的组合继承
package main
import "fmt"
// 可以闻
type Smellable interface {
smell()
}
// 可以吃
type Eatable interface {
eat()
}
// 接口组合
type Fruitable interface {
Smellable
Eatable
}
// 苹果既可能闻又能吃
type Apple struct{}
func (a Apple) smell() {
fmt.Println("apple can smell")
}
func (a Apple) eat() {
fmt.Println("apple can eat")
}
// 花只可以闻
type Flower struct{}
func (f Flower) smell() {
fmt.Println("flower can smell")
}
func main() {
var s1 Smellable
var s2 Eatable
var apple = Apple{}
var flower = Flower{}
s1 = apple
s1.smell() // apple can smell
s1 = flower
s1.smell() // flower can smell
s2 = apple
s2.eat() // apple can eat
var s3 Fruitable
s3 = apple
s3.smell() // apple can smell
s3.eat() // apple can eat
}
原文地址：https://blog.csdn.net/lp15929801907/article/details/140359743
免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！