Go 语言中的 interface 接口简介【GO 基础】

阅读目录

〇、接口简介
一、关于 GO 语言中的接口
二、类型与接口的关系
三、空接口

〇、接口简介

接口（interface）定义了一个对象的行为规范，只定义规范不实现，由具体的对象来实现规范的细节。也就是说，接口可以将一种或多种特征归纳到一起，其他不同的对象通过实现此接口，来表示可以具有此类特征，使得不同的类或模块之间进行通信和交互，而不需要了解彼此的具体实现细节，从而提高代码的可重用性和可维护性。此外，接口还可以帮助程序员更好地组织和管理代码。

基于接口如此优秀的基础条件，Go 语言当然也不会或缺它的身影，本文将结合示例来详细介绍下。

回到顶部

一、关于 GO 语言中的接口

1.1 接口的定义

Go 语言提倡面向接口编程。

在 Go 语言中接口（interface）是一种类型，一种抽象的类型。

interface 是一组 method 的集合，是 duck-type programming（鸭式编程，在这种风格中，一个对象有效的语义，不是由继承自特定的类或实现特定的接口，而是由当前方法和属性的集合决定）的一种体现。

接口做的事情就像是定义一个协议（规则），只要一台机器有洗衣服和甩干的功能，我就称它为洗衣机。不关心属性（数据），只关心行为（方法）。（我们并不关心对象是什么类型，或者它到底是不是鸭子，只关心行为）

Go 语言提倡面向接口编程。

任何类型的方法集中，只要实现了该接口中定义的全部对应方法，就表示它“实现”了该接口，无须在该类型上显式声明实现了哪个接口，这称为 Structural Typing。所谓对应方法，是指有相同名称、参数列表（不包括参数名）以及返回值。另外，该类型还可以有其他方法。

关于接口的特点有：

接口只有方法声明，没有实现，没有数据字段。
接口可以匿名嵌入其他接口，或嵌入到结构中。
对象赋值给接口时，会发生拷贝，而接口内部存储的是指向这个复制品的指针，既无法修改复制品的状态，也无法获取指针。
只有当接口存储的类型和对象都为 nil 时，接口才等于 nil。
接口调用不会做 receiver 的自动转换。
接口同样支持匿名字段方法。
接口也可实现类似 OOP 中的多态。
空接口可以作为任何类型数据的容器。
一个类型可实现多个接口。
接口命名习惯以 er 结尾。

接口的定义格式：

 // 接口的定义，每个接口由一个或多个方法定义组成
type 接口类型名 interface{
    方法名1( 参数列表1 ) 返回值列表1
    方法名2( 参数列表2 ) 返回值列表2
    ...
}
// 接口名：使用 type 将接口定义为自定义的类型名。接口名最好要能突出该接口的类型含义。
//   例如，有写操作的接口叫 Writer，有字符串功能的接口叫 Stringer 等。以 er 结尾。
// 方法名：当方法名【首字母是大写】且这个【接口类型名首字母也是大写】时，
//   这个方法可以被接口所在的包（package）之外的代码访问。
// 参数列表、返回值列表：参数列表和返回值列表中的【参数变量名可以省略】。
// 示例：
type writer interface{
    Write([]byte) error
}
// 就上边声明的这个接口类型，实际上是看不出来它可以做什么，
// 唯一知道的就是可以通过它的 Write 方法来做一些事情。

1.2 为什么要使用接口

知道了接口如何定义后，其实还有另一个疑问，那就是为啥要用接口，它能带来哪些便利呢？

如下分别以普通方式和接口方式示例：

 package main
 
import "fmt"
 
type Sayer interface {
	Say() string
}
 
type Cat struct{}
type Dog struct{}
 
// 因为 Sayer 接口里只有一个 say 方法
// 所以我们只需要给 Dog 和 Cat 分别实现 say 方法就可以实现 Sayer 接口了
func (c Cat) Say() string { return "喵喵喵" }
func (d Dog) Say() string { return "汪汪汪" }
 
func main() {
	// 普通方式
	c := Cat{}
	fmt.Println("猫:", c.Say())
	d := Dog{}
	fmt.Println("狗:", d.Say())
	// 接口方式
	var ss Sayer // 接口类型变量，能够存储所有实现了该接口的实例
	ss = Cat{}
	fmt.Println("猫:", ss.Say())
	ss = Dog{}
	fmt.Println("狗:", ss.Say())
}

两种方式都可以达到同样的目的，但是很明显接口方式更具可扩展性，当后续又新增了猪牛羊等动物时，无需再新增变量，都可以赋值给接口 Sayer 对象的实例。

接口区别于我们之前所有的具体类型，接口是一种抽象的类型。当你看到一个接口类型的值时，你不知道它是什么，唯一知道的是通过它的方法能做什么。

1.3 接口实现的条件

一个对象只要全部实现了接口中的方法，那么就实现了这个接口。换句话说，接口就是一个需要实现的方法列表。

例如，上一章节中的示例代码中，接口 Sayer 声明时，只包含一个方法，则 Cat、Dog 只要实现了 Say 方法就算实现了接口。

1.4 值接收者和指针接收者实现接口的区别

值接收者示例代码：

 package main
 
import "fmt"
 
type Mover interface {
	Move()
}
type dog struct{}
 
func (d dog) Move() {
	fmt.Println("狗会动")
}
 
func main() {
	var x Mover
	var wangcai = dog{} // 旺财是 dog 类型
	x = wangcai         // x 可以接收 dog 类型
	x.Move()
	var fugui = &dog{} // 富贵是 *dog 类型
	x = fugui          // x 可以接收 *dog 类型
	x.Move()
}

从上面的代码中我们可以发现，使用值接收者实现接口之后，不管是 dog 结构体还是结构体指针 *dog 类型的变量都可以赋值给该接口变量。因为 Go 语言中有对指针类型变量求值的语法糖，dog 指针 fugui 内部会自动求值 *fugui。

但是，当接收者变更为指针后，接口对象就只能接收指针类型了，如果直接接收对象，则会报异常。如下指针接收者的示例代码：

 package main
 
import "fmt"
 
type Mover interface {
	Move()
}
type dog struct{}
 
func (d *dog) Move() {
	fmt.Println("狗会动")
}
 
func main() {
	var x Mover
	// var wangcai = dog{} // 旺财是 dog 类型
	// x = wangcai         // x 不可以接收 dog 类型
	// cannot use wangcai (variable of type dog) as Mover value in assignment: dog does not implement Mover (method Move has pointer receiver)compilerInvalidIfaceAssign
	x.Move()
	var fugui = &dog{} // 富贵是 *dog 类型
	x = fugui          // x 可以接收 *dog 类型
	x.Move()
}

回到顶部

二、类型与接口的关系

2.1 一个类型实现多个接口

一个类型可以同时实现多个接口，而接口间彼此独立，不知道对方的实现。例如，狗可以叫，也可以动。就可以分别定义 Sayer 接口和 Mover 接口，然后让 Dog 对象分别实现两个接口，代码如下：

 package main
 
import (
	"fmt"
)
 
// Sayer 接口
type Sayer interface {
	say()
}
 
// Mover 接口
type Mover interface {
	move()
}
type Dog struct {
	name string
}
 
// 实现 Sayer 接口
func (d Dog) say() {
	fmt.Printf("%s会叫\n", d.name)
}
 
// 实现 Mover 接口
func (d Dog) move() {
	fmt.Printf("%s会动\n", d.name)
}
 
func main() {
	var x Sayer
	var y Mover
	var a = Dog{name: "旺财"} // Dog 实现了两个接口后，就可以把其复制给各个接口的实例
	x = a
	x.say() // 输出：旺财会叫
	y = a
	y.move() // 输出：旺财会动
}

2.2 多个类型实现同一接口

Go 语言中不同的类型还可以实现同一接口。

下面一段示例代码，狗和汽车都可以移动，它们都可以实现 Mover 接口：

 package main
 
import (
	"fmt"
)
 
// Mover 接口
type Mover interface {
	move()
}
type Dog struct {
	name string
}
 
type Car struct {
	brand string
}
 
// Dog 类型实现 Mover 接口
func (d Dog) move() {
	fmt.Printf("%s会跑\n", d.name)
}
 
// Car 类型实现 Mover 接口
func (c Car) move() {
	fmt.Printf("%s速度七十迈\n", c.brand)
}
func main() {
	var x Mover
	var a = Dog{name: "旺财"}
	var b = Car{brand: "比亚迪"}
	x = a
	x.move() // 输出：旺财会跑
	x = b
	x.move() // 输出：比亚迪速度七十迈
}

2.3 如何在未全部实现接口方法的条件下，实现赋值

一个接口的方法，不一定需要由一个类型完全实现，接口的方法可以通过在类型中嵌入其他类型或者结构体来实现。

要注意的是，嵌套的的结构体和原结构体中实现的方法，需要包含全部接口中的方法。

如下示例代码，声明一个洗衣机接口，包含‘洗’和‘甩干’两个方法。海尔洗衣机实现了‘洗’方法，同时其中的甩干器又实现了‘甩干’方法。最终结果就是海尔洗衣机实现了洗衣机的全部方法，即实现了洗衣机接口：

 package main
 
import (
	"fmt"
)
 
// WashingMachine 洗衣机
type WashingMachine interface {
	wash()
	dry()
}
 
// 甩干器
type dryer struct{}
 
// 实现 WashingMachine 接口的 dry() 方法
func (d dryer) dry() {
	fmt.Println("甩一甩")
}
 
// 海尔洗衣机
type haier struct {
	dryer // 嵌入甩干器
}
 
// 实现 WashingMachine 接口的 wash() 方法
func (h haier) wash() {
	fmt.Println("洗刷刷")
}
 
func main() {
	var x WashingMachine
	var a dryer
	// x = a // dryer 仅实现了接口的一个方法，不算实现了，无法赋值给 x
	// x.dry()
	var b = haier{a}
	x = b
	x.wash() // 输出：洗刷刷
}

WashingMachine 中的两个方法，在结构体 dryer 和 harer 中得到了全部实现。因此被嵌入的结构体 haier 的实例可以赋值给接口的实例。

2.4 多个接口可以嵌套

接口与接口间可以通过嵌套创造出新的接口。

如下示例代码，接口 animal 中嵌套了两个接口 Sayer 和 Mover：

 package main
 
import (
	"fmt"
)
 
// Sayer 接口
type Sayer interface {
	say()
}
 
// Mover 接口
type Mover interface {
	move()
}
 
// 接口嵌套
type animal interface {
	Sayer
	Mover
}
type cat struct {
	name string
}
 
func (c cat) say() {
	fmt.Println("喵喵喵")
}
 
func (c cat) move() {
	fmt.Println("猫会动")
}
 
func main() {
	var x animal
	var c = cat{name: "花花"}
	x = c
	x.move()
	x.say()
}

回到顶部

三、空接口

3.1 空接口的定义

空接口是指没有定义任何方法的接口，因此，任何类型都实现了空接口。所以，空接口类型的变量可以存储任意类型的变量。

如下示例代码，定义一个空接口，分别将其他类型的变量赋值给空接口的实例：

 package main
 
import (
	"fmt"
)
 
func main() {
	var x interface{} // 定义一个空接口 x
	s := "a.string"
	x = s
	fmt.Printf("type:%T value:%v\n", x, x) // type:string value:a.string
	i := 100
	x = i
	fmt.Printf("type:%T value:%v\n", x, x) // type:int value:100
	b := true
	x = b
	fmt.Printf("type:%T value:%v\n", x, x) // type:bool value:true
}

3.2 空接口的应用

可作为函数的参数：

 package main
 
import (
	"fmt"
)
 
// 空接口作为函数参数
func show(a interface{}) {
	fmt.Printf("type:%T value:%v\n", a, a)
}
func main() {
	var x interface{} // 定义一个空接口 x
	s := "a.string"
	x = s
	show(x) // type:string value:a.string
	i := 100
	x = i
	show(x) // type:int value:100
	b := true
	x = b
	show(x) // type:bool value:true
}

空接口作为 map 的值：

使用空接口实现可以保存任意类型值的字典。

 package main
 
import (
	"fmt"
)
 
func main() {
	var studentInfo = make(map[string]interface{}) // 空接口作为 map 值
	studentInfo["name"] = "李白"
	studentInfo["age"] = 18
	studentInfo["married"] = false
	fmt.Println(studentInfo) // map[age:18 married:false name:李白]
}

3.3 类型断言

空接口可以存储任意类型的值，那么从中取值的时候怎么判断值类型呢？下面来看下。

一个接口的值（简称接口值）是由一个具体类型和具体类型的值两部分组成的。这两部分分别称为接口的动态类型和动态值。

想要判断空接口中的值这个时候就可以使用类型断言，其语法格式：

 x.(T)
// x：表示类型为 interface{} 的变量
// T：表示断言 x 可能是的类型

该语法返回两个参数，第一个参数是 x 转化为 T 类型后的变量，第二个值是一个布尔值，若为 true 则表示断言成功，为 false 则表示断言失败。

如下一段简单的示例代码：

 package main
 
import "fmt"
 
func main() {
	var x interface{}
	x = "测试文本" // 当 x = 1 时，返回“类型断言失败”
	v, ok := x.(string)
	if ok {
		fmt.Println(v)
	} else {
		fmt.Println("类型断言失败")
	}
}

如果断言失败，返回值 v 就是指定类型的默认值，比如 int 就是 0，bool 就是 false。

上面的示例中如果要断言多次就需要写多个 if 判断，这个时候我们可以使用 switch 语句来实现：

 package main
 
import (
	"fmt"
)
 
func main() {
	var x interface{}
	i := 10
	x = i
	justifyType(x)
}
func justifyType(x interface{}) {
	switch v := x.(type) {
	case string:
		fmt.Printf("x is a string，value is %v\n", v)
	case int:
		fmt.Printf("x is a int is %v\n", v)
	case bool:
		fmt.Printf("x is a bool is %v\n", v)
	default:
		fmt.Println("unsupport type！")
	}
}
// 输出：x is a int is 10

因为空接口可以存储任意类型值的特点，所以空接口在Go语言中的使用十分广泛。

关于接口需要注意的是：

只有当有两个或两个以上的具体类型，必须以相同的方式进行处理时才需要定义接口。不要为了接口而写接口，那样只会增加不必要的抽象，导致不必要的运行时损耗。

参考：http://www.topgoer.com/%E9%9D%A2%E5%90%91%E5%AF%B9%E8%B1%A1/%E6%8E%A5%E5%8F%A3.html

posted @ 2023-10-11 17:48 橙子家阅读(358) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

公告

欢迎关注我的公众号【橙子家czzj】
可以随时随地查看历史博文！
还可以第一时间接收推送！

昵称：橙子家
园龄： 5年3个月
粉丝： 74
关注： 11

+加关注

2025年3月

日

一

二

三

四

五

六

橙子家

Go 语言中的 interface 接口简介【GO 基础】

〇、接口简介

一、关于 GO 语言中的接口

1.1 接口的定义

1.2 为什么要使用接口

1.3 接口实现的条件

1.4 值接收者和指针接收者实现接口的区别

二、类型与接口的关系

2.1 一个类型实现多个接口

2.2 多个类型实现同一接口

2.3 如何在未全部实现接口方法的条件下，实现赋值

2.4 多个接口可以嵌套

三、空接口

3.1 空接口的定义

3.2 空接口的应用

3.3 类型断言

公告

随笔分类

随笔档案

阅读排行榜

推荐排行榜

最新评论

	// 接口的定义，每个接口由一个或多个方法定义组成
	type 接口类型名 interface{
	方法名1( 参数列表1 ) 返回值列表1
	方法名2( 参数列表2 ) 返回值列表2
	...
	}
	// 接口名：使用 type 将接口定义为自定义的类型名。接口名最好要能突出该接口的类型含义。
	// 例如，有写操作的接口叫 Writer，有字符串功能的接口叫 Stringer 等。以 er 结尾。
	// 方法名：当方法名【首字母是大写】且这个【接口类型名首字母也是大写】时，
	// 这个方法可以被接口所在的包（package）之外的代码访问。
	// 参数列表、返回值列表：参数列表和返回值列表中的【参数变量名可以省略】。
	// 示例：
	type writer interface{
	Write([]byte) error
	}
	// 就上边声明的这个接口类型，实际上是看不出来它可以做什么，
	// 唯一知道的就是可以通过它的 Write 方法来做一些事情。

	package main

	import "fmt"

	type Sayer interface {
	Say() string
	}

	type Cat struct{}
	type Dog struct{}

	// 因为 Sayer 接口里只有一个 say 方法
	// 所以我们只需要给 Dog 和 Cat 分别实现 say 方法就可以实现 Sayer 接口了
	func (c Cat) Say() string { return "喵喵喵" }
	func (d Dog) Say() string { return "汪汪汪" }

	func main() {
	// 普通方式
	c := Cat{}
	fmt.Println("猫:", c.Say())
	d := Dog{}
	fmt.Println("狗:", d.Say())
	// 接口方式
	var ss Sayer // 接口类型变量，能够存储所有实现了该接口的实例
	ss = Cat{}
	fmt.Println("猫:", ss.Say())
	ss = Dog{}
	fmt.Println("狗:", ss.Say())
	}

	package main

	import "fmt"

	type Mover interface {
	Move()
	}
	type dog struct{}

	func (d dog) Move() {
	fmt.Println("狗会动")
	}

	func main() {
	var x Mover
	var wangcai = dog{} // 旺财是 dog 类型
	x = wangcai // x 可以接收 dog 类型
	x.Move()
	var fugui = &dog{} // 富贵是 *dog 类型
	x = fugui // x 可以接收 *dog 类型
	x.Move()
	}

	package main

	import (
	"fmt"
	)

	// Sayer 接口
	type Sayer interface {
	say()
	}

	// Mover 接口
	type Mover interface {
	move()
	}
	type Dog struct {
	name string
	}

	// 实现 Sayer 接口
	func (d Dog) say() {
	fmt.Printf("%s会叫\n", d.name)
	}

	// 实现 Mover 接口
	func (d Dog) move() {
	fmt.Printf("%s会动\n", d.name)
	}

	func main() {
	var x Sayer
	var y Mover
	var a = Dog{name: "旺财"} // Dog 实现了两个接口后，就可以把其复制给各个接口的实例
	x = a
	x.say() // 输出：旺财会叫
	y = a
	y.move() // 输出：旺财会动
	}

	x.(T)
	// x：表示类型为 interface{} 的变量
	// T：表示断言 x 可能是的类型