interface类型可以定义一组方法,但是这些不需要实现。并且interface不能包含任何变量。到某个自定义类型(比如结构体Phone)要使用的时候,在根据具体情况把这些方法写出来(实现)。
**基本语法**
![](https://img.kancloud.cn/25/92/2592e408b87238b9d67db4c0a1e596ad_1133x263.png)
小结说明
1)接口里的所有方法都没有方法体,即接口的方法都是没有实现的方法。接口体现了程序设计的多态和高内聚低偶合的思想。
2)Golang中的接口,不需要显式的实现。只要一个变量,含有接口类型中的所有方法,那么这个变量就实现这个接口。因此,Golang中没有implement这样的关键字
**接口使用的应用场景**
![](https://img.kancloud.cn/29/9c/299cb4d80211957f523066683bf51e9f_1057x538.png)
![](https://img.kancloud.cn/2a/d6/2ad6b5993c102472c572cdbed427fe48_1022x441.png)
示例:下面的sort函数传入的变量实现下面的接口就可以使用sort这个方法
![](https://img.kancloud.cn/7f/5f/7f5ff8c0a5ca63cc3916cbca62372125_388x88.png)
![](https://img.kancloud.cn/01/ab/01ababcceac20517219b9dfd54a1dbda_527x275.png)
**注意事项和细节**
1)接口本身不能创建实例,但是可以指向一个实现了该接口的自定义类型的变量(实例)
![](https://img.kancloud.cn/6b/8e/6b8e7d6d7b36626b4ec1247edaa579b0_925x533.png)
2)接口中所有的方法都没有方法体,即都是没有实现的方法。
3)在Golang中,一个自定义类型需要将某个接口的所有方法都实现,我们说这个自定义类型实现了该接口。
4)一个自定义类型只有实现了某个接口,才能将该自定义类型的实例(变量)赋给接口类型
5)只要是自定义数据类型,就可以实现接口,不仅仅是结构体类型。
![](https://img.kancloud.cn/f2/2f/f22fb3a395d280b56e7780854e6c2f12_664x302.png)
6)一个自定义类型可以实现多个接口
![](https://img.kancloud.cn/e0/6e/e06ec0ed730fd94b4b864f1ac6170882_783x661.png)
7)Golang接口中不能有任何变量
![](https://img.kancloud.cn/39/c8/39c8677364a2ab7f63adeca0dd079989_436x138.png)
8)一个接口(比如A接口)可以继承多个别的接口(比如B,C接口),这时如果要实现A接口,也必须将B,C接口的方法也全部实现。
![](https://img.kancloud.cn/cc/d7/ccd750ab95ac0e6696270eb90c9a3ab4_731x767.png)
9)interface类型默认是一个指针(引用类型),如果没有对interface初始化就使用,那么会输出nil
10)空接口interface{}没有任何方法,所以所有类型都实现了空接口,即我们可以把任何一个变量赋给空接口。
![](https://img.kancloud.cn/23/30/2330ceb5bb22228b449283a7e368d6e1_440x105.png)
![](https://img.kancloud.cn/6c/9b/6c9b17c28a93e235adccd6bfcd5e4019_610x204.png)
![](https://img.kancloud.cn/82/9d/829df7f2965fcf581e4c1da0586000d3_593x575.png)
![](https://img.kancloud.cn/a8/65/a8653a1cc8fd2cacd8f4c18f84edf183_619x514.png)
![](https://img.kancloud.cn/26/8c/268c46a36300fda1a0f82da7538026a1_713x488.png)
**接口编程的最佳实践**
实现对Hero结构体切片的排序:sort.Sort(dataInterface)
```
package main
import (
"fmt"
"sort"
"math/rand"
)
//1.声明 Hero 结构体
type Hero struct{
Name string
Age int
}
//2.声明一个 Hero 结构体切片类型
type HeroSlice \[\]Hero
//3.实现 Interface 接口
func (hs HeroSlice) Len() int {
return len(hs)
}
//Less 方法就是决定你使用什么标准进行排序
//1. 按 Hero 的年龄从小到大排序!!
func (hs HeroSlice) Less(i, j int) bool {
return hs\[i\].Age < hs\[j\].Age
//修改成对 Name 排序
//return hs\[i\].Name < hs\[j\].Name
}
func (hs HeroSlice) Swap(i, j int) {
//交换
// temp := hs\[i\]
// hs\[i\] = hs\[j\]
// hs\[j\] = temp
//下面的一句话等价于三句话
hs\[i\], hs\[j\] = hs\[j\], hs\[i\]
}
//1.声明 Student 结构体
type Student struct{
Name string
Age int
Score float64
}
//将 Student 的切片,安 Score 从大到小排序!!
func main() {
//先定义一个数组/切片
var intSlice = \[\]int{0, -1, 10, 7, 90}
//要求对 intSlice 切片进行排序
//1. 冒泡排序...
//2. 也可以使用系统提供的方法
sort.Ints(intSlice)
fmt.Println(intSlice)
//请大家对结构体切片进行排序
//1. 冒泡排序...
//2. 也可以使用系统提供的方法
//测试看看我们是否可以对结构体切片进行排序
var heroes HeroSlice
for i := 0; i < 10 ; i++ {
hero := Hero{
Name : fmt.Sprintf("英雄|%d", rand.Intn(100)),
Age : rand.Intn(100),
}
//将 hero append 到 heroes 切片
heroes = append(heroes, hero)
}
//看看排序前的顺序
for \_ , v := range heroes {
fmt.Println(v)
}
//调用 sort.Sort
sort.Sort(heroes)
fmt.Println("-----------排序后\------------") //看看排序后的顺序
for _ , v := range heroes {
fmt.Println(v)
}
i := 10
j := 20
i, j = j, i
fmt.Println("i=", i, "j=", j) // i=20 j = 10
}
```
## 实现接口 vs 继承
大家听到现在,可能会对实现接口和继承比较迷茫了, 这个问题,那么他们究竟有什么区别呢
![](https://img.kancloud.cn/7a/e1/7ae1c0f9e7772d42dd1c56746f953ad9_1044x514.png)
![](https://img.kancloud.cn/c4/b9/c4b905f310a539c21b92eeb55d0aec3d_1104x744.png)
![](https://img.kancloud.cn/d5/f2/d5f275fffbfd9c65e1f1e12996d8326f_957x866.png)
对上面代码的小结
1) 当 A 结构体继承了 B 结构体,那么 A 结构就自动的继承了 B 结构体的字段和方法,并且可以直接使用
2) 当 A 结构体需要扩展功能,同时不希望去破坏继承关系,则可以去实现某个接口即可,因此我们可以认为:实现接口是对继承机制的补充.
![](https://img.kancloud.cn/8d/17/8d177b6eb3abd17fc41618a847a6a549_1076x337.png)
(1) 接口和继承解决的解决的问题不同
继承的价值主要在于:解决代码的复用性和可维护性。
(2) 接口的价值主要在于:设计,设计好各种规范(方法),让其它自定义类型去实现这些方法。
(3) 接口比继承更加灵活 Person Student BirdAble LittleMonkey
接口比继承更加灵活,继承是满足 is - a 的关系,而接口只需满足 like - a 的关系。
(4)接口在一定程度上实现代码解耦
## **面向对象编程-多态**
变量(实例)具有多种形态。面向对象的第三大特征,在 Go 语言,多态特征是通过接口实现的。可以按照统一的接口来调用不同的实现。这时接口变量就呈现不同的形态。(在面向对象的理论 中,多态性的一般定义为:同一个操作作用于不同的类的实例,将产生不同的执行结果。也即不同类的对象收到相同的消息时,将得到不同的结果。)
在前面的 Usb 接口案例,Usb usb ,既可以接收手机变量,又可以接收相机变量,就体现了 Usb 接口 多态特性。[点明]
### **接口体现多态的两种形式**
(1)多态参数
在前面的 Usb 接口案例,Usb usb ,即可以接收手机变量,又可以接收相机变量,就体现了 Usb 接 口 多态。
```
package main import ( "fmt" )//声明/定义一个接口
type Usb interface { //声明了两个没有实现的方法
Start()
Stop()
}
type Phone struct {
}
//让 Phone 实现 Usb 接口的方法
func (p Phone) Start() {
fmt.Println("手机开始工作。。。")
}
func (p Phone) Stop() {
fmt.Println("手机停止工作。。。")
}
type Camera struct {
}
//让 Camera 实现 Usb 接口的方法
func (c Camera) Start() {
fmt.Println("相机开始工作。。。")
}
func (c Camera) Stop() {
fmt.Println("相机停止工作。。。")
}
//计算机
type Computer struct {
}
//编写一个方法 Working 方法,接收一个 Usb 接口类型变量
//只要是实现了 Usb 接口 (所谓实现 Usb 接口,就是指实现了 Usb 接口声明所有方法)
func (c Computer) Working(usb Usb) { //usb 变量会根据传入的实参,来判断到底是 Phone,还是 Camera
//通过 usb 接口变量来调用 Start 和 Stop 方法
usb.Start()
usb.Stop()
}
func main() {
//测试
//先创建结构体变量
computer := Computer{}
phone := Phone{}
camera := Camera{}
//关键点
computer.Working(phone)
computer.Working(camera) //
}
```
(2)多态数组(数组中正常只能放一种数据类型我们用接口提现多态)
给 Usb 数组中,存放 Phone 结构体 和 Camera 结构体变量
```
package main
import (
"fmt"
)
//声明/定义一个接口
type Usb interface {
//声明了两个没有实现的方法
Start()
Stop()
}
type Phone struct {
name string
}
//让 Phone 实现 Usb 接口的方法
func (p Phone) Start() {
fmt.Println("手机开始工作。。。")
}
func (p Phone) Stop() {
fmt.Println("手机停止工作。。。")
}
type Camera struct {
name string
}
//让 Camera 实现 Usb 接口的方法
func (c Camera) Start() {
fmt.Println("相机开始工作。。。")
}
func (c Camera) Stop() {
fmt.Println("相机停止工作。。。")
}
func main() {
//定义一个 Usb 接口数组,可以存放 Phone 和 Camera 的结构体变量
//这里就体现出多态数组
var usbArr \[3\]Usb
usbArr\[0\] = Phone{"vivo"}
usbArr\[1\] = Phone{"小米"}
usbArr\[2\] = Camera{"尼康"}
fmt.Println(usbArr)
}
```
## **类型断言**
![](https://img.kancloud.cn/62/aa/62aadd77b1e241964ef3372dff0c6507_954x379.png)
在进行类型断言时,如果类型不匹配,就会报 panic, 因此进行类型断言时,要确保原来的空接口指向的就是断言的类型.
如何在进行断言时,带上检测机制,如果成功就 ok,否则也不要报 panic
![](https://i.vgy.me/pW1Gwd.png)
### **类型断言的最佳实践 1**
给 Phone 结构体增加一个特有的方法 call(), 当 Usb 接口接收的是 Phone 变量时,还需要调用 call方法, 走代码:
```
package main
import (
"fmt"
)
//声明/定义一个接口
type Usb interface {
//声明了两个没有实现的方法
Start()
Stop()
}
type Phone struct {
name string
}
//让 Phone 实现 Usb 接口的方法
func (p Phone) Start() {
fmt.Println("手机开始工作。。。")
}
func (p Phone) Stop() {
fmt.Println("手机停止工作。。。")
}
func (p Phone) Call() {
fmt.Println("手机 在打电话..")
}
type Camera struct {
name string
}
//让 Camera 实现 Usb 接口的方法
func (c Camera) Start() {
fmt.Println("相机开始工作。。。")
}
func (c Camera) Stop() {
fmt.Println("相机停止工作。。。")
}
type Computer struct {
}
func (computer Computer) Working(usb Usb) {
usb.Start()
//如果 usb 是指向 Phone 结构体变量,则还需要调用 Call 方法
//类型断言..\[注意体会!!!\]
if phone, ok := usb.(Phone); ok {
phone.Call()
}
usb.Stop()
}
func main() {
//定义一个 Usb 接口数组,可以存放 Phone 和 Camera 的结构体变量
//这里就体现出多态数组
var usbArr \[3\]Usb
usbArr\[0\] = Phone{"vivo"}
usbArr\[1\] = Phone{"小米"}
usbArr\[2\] = Camera{"尼康"}
//遍历 usbArr
//Phone 还有一个特有的方法 call(),请遍历 Usb 数组,如果是 Phone 变量,
//除了调用 Usb 接口声明的方法外,还需要调用 Phone 特有方法 call. =》类型断言
var computer Computer
for \_, v := range usbArr{
computer.Working(v)
fmt.Println()
}
//fmt.Println(usbArr)
}
```
### **类型断言的最佳实践 2**
写一函数,循环判断传入参数的类型:
注意以下程序中typeJudge中用...代表不确定的个数的实参0-多个 interface{}空的接口代表着任意类型因为空接口 (因为所有类型都实现了空接口)
![](https://i.vgy.me/hondHH.png)
![](https://i.vgy.me/hOfFLj.png)