Go（4）--接口

柔光的暖阳◎ 2021-08-29 19:35 528阅读 0赞

### 接口 ###

*  1. 基本概念
 *   *  1.1 接口声明
     *   *  1.1.1 声明新接口的特点
     *  1.2 接口初始化
     *   *  1.2.1 实例赋值接口
         *  1.2.2 接口变量赋值接口变量
     *  1.3 接口方法调用
     *  1.4 接口的动态类型和静态类型
     *   *  1.4.1 动态类型
         *  1.4.2 静态类型
 *  2. 接口运算
 *   *  2.1 类型断言
     *  2.2 类型查询
     *  2.3 接口优点和使用形式
 *  3. 空接口
 *   *  3.1 基本概念
     *  3.2 空接口的用途
     *  3.3 空接口和 nil

>       Go的接口是非侵入式的设计，一个具体类型实现接口不需要在语法上显式地声明，只要具体类型的方法集是接口方法集的超集，就代表该类型实现了接口。

# 1. 基本概念 #

## 1.1 接口声明 ##

>       Go 语言的接口分为接口字面量和接口命名类型，接口的声明2使用 `interface`关键字。

*  接口字面量类型的声明语法如下：

interface{ 
    	MethodSignature1
    	MethodSignature2
    }

*  接口命名类型使用`type`关键字声明，语法如下：

type InterfaceName interface{ 
    	MethodSignature1
    	MethodSignature2
    }

接口定义大括号可以是方法声明的集合，也可以嵌入另一个接口类型匿名字段，还可以是二者的混合。接口支持嵌入匿名接口字段，就是一个接口定义里面可以包括其他接口，Go 编译器会自动进行展开。

type Reader interface{ 
    	Read(p []byte)(n int, err error)
    }
    
    type Writer interface{ 
    	Write(p []byte)(n int, err error)
    }
    
    // 以下3种声明是等价的，最终的转开模式都是第3种格式
    
    type ReadWriter interface{ 
    	Reader
    	Writer
    }
    
    type ReadWriter interface{ 
    	Reader
    	Write(p []byte)(n int, err error)
    }
    
    type ReadWriter interface{ 
    	Read(p []byte)(n int, err error)
    	Write(p []byte)(n int, err error)
    }

### 1.1.1 声明新接口的特点 ###

1.  接口的命名一般以 `er` 结尾
2.  接口定义的内部方法声明不需要`func`引导
3.  在接口定义种，只有方法声明没有方法实现

## 1.2 接口初始化 ##

>       接口作为一个抽象层，起到抽象和适配的作用。没有初始化的接口变量，其默认是 `nil`。

package main
    
    import (
    	"fmt"
    	"io"
    )
    
    func main()  { 
    
    	var i io.Reader
    
    	fmt.Printf("i value = %v \n", i, i) // nil
    }

接口所绑定具体类型的实例的过程称为接口初始化。接口变量支持两种直接初始化的方法。

### 1.2.1 实例赋值接口 ###

如果具体类型实现了接口的所有方法，则称该具体类型实现了接口，可以将该具体类型的实例直接赋值给接口类型的变量。

package main
    
    import (
    	"fmt"
    )
    
    // 申明一个接口
    type Car interface { 
    	Run()
    }
    
    // 申明一个具体的类型
    type Truck struct { 
    
    }
    
    // 具体类型实现接口的方法
    func (t Truck)Run()  { 
    	fmt.Println("Truck Is Running")
    }
    
    
    func main()  { 
    	var car Car
    	var truck Truck
    	car = truck // 将一个具体类型实例直接赋值给接口
    	car.Run() // Truck Is Running
    }

### 1.2.2 接口变量赋值接口变量 ###

已经初始化的接口类型变量`a`直接赋值给另一种接口变量`b`，要求`b`的方法集是`a`的方法集的子集。

file, _ := os.Open("notes.txt")
    	
    	var rw io.ReadWriter = file
    	// io.ReadWriter 接口可以直接赋值给 io.Writer 接口变量
    	var w io.Writer = rw

## 1.3 接口方法调用 ##

接口方法调用的最终地址是在运行期决定的，将具体类型变量赋值给接口后，会使用具体类型的方法指针初始化接口变量，当调用接口变量的方法时，实际上是间接地调用实例地方法。

直接调用未初始化地接口变量的方法会产生`panic`。

## 1.4 接口的动态类型和静态类型 ##

### 1.4.1 动态类型 ###

接口绑定的具体实例的类型称为接口的动态类型。接口可以绑定不同类型的实例，所以接口的动态类型是随着绑定的不同类型的实例而发生变化的。

### 1.4.2 静态类型 ###

接口被定义时，其类型就已经被确定，这个类型叫接口的静态类型。接口的静态类型在其定义时就被确定，静态类型的本质特征就是接口的方法签名集合。两个接口如果方法签名集合相同（方法的顺序可以不同），则这两个接口在语义上完全等价，它们之间不需要强制类型转化就可以相互赋值。原因是 **Go 编译器检验接口是否能赋值，是比较二者的方法集，而不是看具体接口的类型名**。a 接口的方法集为 A，b 接口的方法集为 B，如果 B 是 A 的子集，则 a 的接口变量可以直接赋值给 B 的接口变量。反之，需要使用类型断言。

# 2. 接口运算 #

编程过程中有时需要确认已经初始化的接口变量指向实例的具体类型是什么，也需要检查运行时的接口类型。

Go 语言提供两种语法接口来支持这两种需求，分别时类型断言和接口类型查询。

## 2.1 类型断言 ##

接口类型断言的语法形式如下：

`i.(TypeName)`

i 必须是接口变量，如果是具体类型变量，则报错。TypeName 可以是接口类型名，也可以是具体类型名。

**接口断言的两层语义：**

1.  如果 `TypeName`是一个具体类型名，则类型断言用于判断接口变量 `i` 所绑定的实例类型是否是具体类型`TypeName`。
2.  如果 `TypeName`是一个接口类型名，则类型断言用于判断接口变量 `i` 所绑定的实例类型是否同时实现了 `TypeName`接口。

**接口断言的两种语法表现：**

1.  直接赋值模式如下：

o := i.(TypeName)

语义分析：

1. `TypeName`是具体类型名，此时如果接口`i`绑定的实例类型就i是具体类型`TypeName`，则变量`o`的类型就是 `TypeName`，变量`o`的值就是接口绑定的实例值的副本。

2. `TypeName`是接口类型名，此时如果接口`i`绑定的实例类型满足接口类型`TypeName`，则变量`o`的类型就是 `TypeName`，`o`底层绑定的具体类型实例是`i`绑定的实例的副本。

3. 如果上述两种情况都不满足，则程序抛出`panic`。

package main
    
    import "fmt"
    
    type Inter interface { 
    	Ping()
    	Pang()
    }
    
    type Anter interface { 
    	Inter
    	String()
    }
    
    type St struct { 
    	Name string
    }
    
    func (St)Ping(){ 
    	fmt.Println("ping")
    }
    
    func (St)Pang(){ 
    	fmt.Println("pang")
    }
    
    func main() { 
    	st := &St{ "wangzhao"}
    
    	var i interface{ } = st
    
    	// 判断 i 所绑定的实例是否实现了接口类型 Inter
    	o := i.(Inter)
    	o.Ping()
    	o.Pang()
    
    	// 如下语句会引发 panic，因为 i 没有实现接口 Anter
    	// p := i.(Anter)
    	// p.String()
    
    	// 判断 i 所绑定的实例是否就是具体类型 St
    	s := i.(*St)
    	fmt.Printf("%s", s.Name)
    }

1.  `comma, ok`表达式模式如下：

if o, ok := i.(TypeName); ok{ 
    
    }

语义分析：

1. `TypeName`是具体类型名，此时如果接口`i`绑定的实例类型就i是具体类型`TypeName`，则`ok`为`true`，变量`o`的类型就是 `TypeName`，变量`o`的值就是接口绑定的实例值的副本。

2. `TypeName`是接口类型名，则`ok`为`true`，此时如果接口`i`绑定的实例类型满足接口类型`TypeName`，则变量`o`的类型就是 `TypeName`，`o`底层绑定的具体类型实例是`i`绑定的实例的副本。

3. 如果上述两种情况都不满足，则`ok`为`false`，变量`o`是`TypeName`类型的“零值”，此种条件分支下程序逻辑不应该再去引用`o`，因为此时`o`没有意义。

package main
    
    import "fmt"
    
    type Inter interface { 
    	Ping()
    	Pang()
    }
    
    type Anter interface { 
    	Inter
    	String()
    }
    
    type St struct { 
    	Name string
    }
    
    func (St)Ping(){ 
    	fmt.Println("ping")
    }
    
    func (St)Pang(){ 
    	fmt.Println("pang")
    }
    
    func main() { 
    	st := &St{ "wangzhao"}
    	var i interface{ } = st
    
    	// 判断 i 所绑定的实例是否实现了接口类型 Inter
    	if o, ok := i.(Inter); ok{ 
    		o.Ping()
    		o.Pang()
    	}
    
    	if p, ok := i.(Anter); ok{ 
    		// i 没有实现接口 Anter，所以程序不会执行到这里
    		p.String()
    	}
    
    	// 如下语句会引发 panic，因为 i 没有实现接口 Anter
    	// p := i.(Anter)
    	// p.String()
    
    	// 判断 i 所绑定的实例是否就是具体类型 St
    	if s, ok := i.(*St); ok{ 
    		fmt.Printf("%s", s.Name)
    	}
    
    }

## 2.2 类型查询 ##

接口类型查询的语法格式如下：

switch v := i.(type){ 
    	case type1:
    		xxx
    	case type2:
    		xxx
    	...
    	default:
    		xxx
    }

**语义分析：**

1.  查询接口变量底层绑定的底层变量的具体类型是什么。
2.  查询接口变量绑定的底层变量是否实现了其他接口。

（1）i 必须是接口类型。

具体类型实例的类型是静态的，在类型声明后不再变化，所以具体类型的变量不存在类型查询。

（2）case 后面剋跟接口类型名，也可以跟非接口类型名。

（3）`fallthrough` 语句不能在类型查询中使用。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdfemhhb18_size_16_color_FFFFFF_t_70]

## 2.3 接口优点和使用形式 ##

*  **接口优点**

（1）解耦：具体类型和实现的接口之间不需要显式声明，增加了接口使用的自由度。

（2）实现泛型：现阶段 Go 语言还不支持泛型，使用空接口作为函数或方法参数能够用在需要泛型的场景中。

*  **接口使用形式**

（1）作为结构体内嵌字段

（2）作为函数或方法的形参

（3）作为函数或方法的返回值

（4）作为其他接口定义的嵌入字段

# 3. 空接口 #

## 3.1 基本概念 ##

没有任何方法的接口，称之为空接口，空接口表示为`interface{}`。Go 中的任意类型都实现了空接口。

## 3.2 空接口的用途 ##

*  泛型

Go 语言没有泛型，如果一个函数需要接收任意类型的参数，则参数类型可以使用空接口类型。

func Fprintln(w io,Writer,a ... interface{ })(n int, err error)

*  反射  
                空接口是反射实现的基础，反射库就i是将相关具体的类型转化并赋值给空接口才去处理。

## 3.3 空接口和 nil ##

空接口有两个字段，一个是实例类型，另一个是指向绑定实例的指针，只有两个都为`nil`时，空接口才是`nil`。

package main
    
    import "fmt"
    
    type Inter interface { 
    	Ping()
    	Pang()
    }
    
    type St struct{ }
    
    func (St) Ping(){ 
    	fmt.Println("ping")
    }
    
    func (*St) Pang(){ 
    	fmt.Println("pang")
    }
    
    func main() { 
    	var st *St = nil
    	var it Inter = st
    
    	fmt.Printf("%p\n", st)
    	fmt.Printf("%p\n", it)
    
    	if it != nil { 
    		it.Pang()
    		
    		// 下面的语句会导致 panic
    		// 方法转化为函数调用，第一个参数是 St 类型，由于 *St 是 nil，无法无法获取指针所指的
    		// 对象值，所以导致 panic
    		// it.Ping()
    	}
    }

![在这里插入图片描述][20200516130404310.png]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dhbmdfemhhb18_size_16_color_FFFFFF_t_70]: /images/20210813/963623b799cf4c998a025c66e0f4a826.png
[20200516130404310.png]: /images/20210813/8f234db509e74b27927e398d5d8a0c58.png