Go語言中interface語法與使用詳解

Posted on by

初識interface

Go語言的面向對象的知識點時，發現它的面向對象能力全靠 interface 撐著，而且它的 interface 還與我們以前知道的 interface 完全不同。故而整個過程不斷的思考為什麼要如此設計？這樣設計給我們帶來瞭什麼影響？

interface(接口)是golang最重要的特性之一，實現多態。Interface類型可以定義一組方法，但是這些不需要實現。並且interface不能包含任何變量。

基本語法

定義一個接口

type Person interface {
    // 聲明方法
    method1(參數列表)返回值列表
    method2(參數列表)返回值列表
}

實現一個接口

func (t 自定義類型）method1(參數列表）返回值列表 {
    //方法實現
}
func (t 自定義類型）method2(參數列表）返回值列表 {
    //方法實現
}

小結：

（1）接口裡的所有方法都沒有方法體，即接口的方法都是沒有實現的方法。接口體現瞭程序設計的多態和高內聚低耦合的思想。

（2）Go中的接口，不需要顯示的實現。隻要一個變量，含有接口類型中的所有方法，那麼這個變量就實現這個接口。因此，Go中沒有implement關鍵字樣。

（3）Go實現接口與方法有關，與接口本身叫什麼名字沒有特別大的關系。變量需要實現接口所有的方法。

其他註意事項

(1)接口本身不能創建實例，但是可以指向一個實現瞭該接口的自定義類型的變量（實例）。

package main

import "fmt"

// Person 定義接口
type Person interface {
	GetName() string
	GetAge() uint32
}

// Student 定義類型
type Student struct {
	Name string
	Age uint32
}

func (s Student) GetName()  string{
	return s.Name
}
func (s Student) GetAge()  uint32{
	return s.Age
}

func main() {

var student Student
	student.Age = 12
	student.Name = "小明"

var person Person
	person = student  //接口執行向student
	fmt.Printf("name:%s,age: %d\n", person.GetName(), person.GetAge())
}

（2）接口中所有的方法都沒有方法體，即都是沒有實現的方法。

（3）在Go中，一個自定義類型需要將某個接口的所有方法都實現，我們說這個自定義類型實現瞭該接口。

（4）一個自定義類型隻有實現瞭某個接口，才能將該自定義類型的實例（變量）賦給接口類型。

（5）隻要是自定義數據類型就可以實現接口，不僅僅是結構體類型。

（6）一個自定義類型可以實現多個接口。

（7）Go接口不能有任何變量。

（8）一個接口可以繼承多個別的接口，這時如果要實現這個接口必須實現它繼承的所有接口的方法。在低版本的Go編輯器中，一個接口繼承其他多個接口時，不允許繼承的接口有相同的方法名。比如A接口繼承B、C接口，B、C接口的方法名不能一樣。高版本的Go編輯器沒有相關問題。

（9）interface類型默認是一個指針（引用類型），如果沒有對interface初始化就使用，那麼會輸出nil。

（10）空接口interface{}沒有任何方法，所以所有類型都實現瞭空接口，即我們可以把任何一個變量賦給空接口類型。

interface底層實現

Go的interface源碼在Golang源碼的runtime目錄中。

Go的interface是由兩種類型來實現的：iface和eface。

iface

iface是包含方法的interface，如：

type Person interface {
	Print()
}

iface的源代碼是：

type iface struct {
	tab  *itab
	data unsafe.Pointer
}

iface具體結構是：

itab是iface不同於eface的關鍵數據結構。其包含兩部分：一部分是唯一確定包含該interface的具體結構類型，一部分是指向具體方法集的指針。其具體結構為：

itab結構

屬性 itab的源代碼是：

type itab struct {
	inter *interfacetype //此屬性用於定位到具體interface
	_type *_type         //此屬性用於定位到具體interface
	hash  uint32         // copy of _type.hash. Used for type switches.
	_     [4]byte
	fun   [1]uintptr     // variable sized. fun[0]==0 means _type does not implement inter.
}

屬性interfacetype類似於_type，其作用就是interface的公共描述，類似的還有maptype、arraytype、chantype…其都是各個結構的公共描述，可以理解為一種外在的表現信息。interfacetype源碼如下：

type interfacetype struct {
	typ     _type
	pkgpath name
	mhdr    []imethod
}
type imethod struct {
	name nameOff
	ityp typeOff
}

iface的整體結構為：

我們來看一個例子，對於含有方法的interface賦值後的內部結構是怎樣的呢？

package main

import "fmt"

// Person 定義接口
type Person interface {
	GetName() string
	GetAge() uint32
}

// Student 定義類型
type Student struct {
	Name string
	Age uint32
}

func (s Student) GetName()  string{
	return s.Name
}
func (s Student) GetAge()  uint32{
	return s.Age
}

func main() {

var student Student
	student.Age = 12
	student.Name = "小明"

var person Person
	person = student
	fmt.Printf("name:%s,age: %d\n", person.GetName(), person.GetAge())
}

運行結果:

name:小明,age: 12

Process finished with the exit code 0

內存分佈示意圖：

eface

eface是不包含方法的interface，即空interface，如：

type Person interface {
}

或者

var person interface{} = xxxx實體

侵入式與非侵入式的理解

侵入式

你的代碼裡已經嵌入瞭別的代碼，這些代碼可能是你引入過的框架，也可能是你通過接口繼承得來的，比如：java中的繼承，必須顯示的表明我要繼承那個接口，這樣你就可以擁有侵入代碼的一些功能。所以我們就稱這段代碼是侵入式代碼。

優點：通過侵入代碼與你的代碼結合可以更好的利用侵入代碼提供給的功能。

缺點：框架外代碼就不能使用瞭，不利於代碼復用。依賴太多重構代碼太痛苦瞭。

非侵入式

正好與侵入式相反，你的代碼沒有引入別的包或框架，完完全全是自主開發。比如go中的接口，不需要顯示的繼承接口，隻需要實現接口的所有方法就叫實現瞭該接口，即便該接口刪掉瞭，也不會影響我，所有go語言的接口數非侵入式接口；再如Python所崇尚的鴨子類型。

優點：代碼可復用，方便移植。非侵入式也體現瞭代碼的設計原則：高內聚，低耦合。

缺點：無法復用框架提供的代碼和功能。

接下來看看java與go語言編程實現接口來理解侵入式與非侵入式的區別。

java語言實現

定義接口

public interface IPersonService {
    String getName();
    Integer getAge();
}

實現接口的類

public class PersonService implements IPersonService{
    @Override
    public String getName() {
        return "小明";
    }
    @Override
    public Integer getAge() {
        return 12;
    }
}

go語言實現

package main
import "fmt"

// Person 定義接口
type Person interface {
	GetName() string
	GetAge() uint32
}
// Student 定義類型
type Student struct {
	Name string
	Age uint32
}

func (s Student) GetName()  string{
	return s.Name
}
func (s Student) GetAge()  uint32{
	return s.Age
}

func main() {

var student Student
	student.Age = 12
	student.Name = "小明"

var person Person
	person = student
	fmt.Printf("name:%s,age: %d\n", person.GetName(), person.GetAge())
}

通過上面的例子我們總結瞭以下問題：

  1. 侵入式通過 implements 把實現類與具體接口綁定起來瞭，因此有瞭強耦合;
  2. 假如修改瞭接口方法，則實現類方法必須改動；
  3. 假如類想再實現一個接口，實現類也必須進行改動；
  4. 後續實現此接口的類，必須瞭解相關的接口；
    Go語言非侵入式的方式很好地解決瞭這幾個問題，隻要實現瞭實現瞭與接口相同的方法，就實現瞭這個接口。隨著代碼量的增加，根本不需要的關心實現瞭哪些接口，不需要刻意去先定義接口再實現接口的固定模式，在原有類新增實現接口時，不需要更改類，做到低侵入式、低耦合開發的好處。

interface的應用場景

類型轉換

類型推斷可將接口變量還原為原始類型，或用來判斷是否實現瞭某個更具體的接口類型。

type data int
  
func(d data)String()string{ 
   return fmt.Sprintf("data:%d",d) 
} 
  
func main() { 
   var d data=15
   var x interface{} =d
  
   if n,ok:=x.(fmt.Stringer);ok{  // 轉換為更具體的接口類型 
       fmt.Println(n) 
    } 
  
   if d2,ok:=x.(data);ok{        // 轉換回原始類型 
       fmt.Println(d2) 
    } 
  
   e:=x.(error)           // 錯誤:main.data is not error
   fmt.Println(e) 
}

輸出為：

data:15
data:15
panic:interface conversion:main.data is not error:missing method Error

但是此處會觸發panic，使用ok-idiom模式，即便轉換失敗也不會引發panic。還可用switch語句在多種類型間做出推斷匹配，這樣空接口就有更多發揮空間。

func main() {
var x interface{} =func(x int)string{ 
       return fmt.Sprintf("d:%d",x) 
    } 
  
   switch v:=x.(type) {            // 局部變量v是類型轉換後的結果 
   case nil: 
       println("nil") 
   case*int: 
       println(*v) 
   case func(int)string: 
       println(v(100)) 
   case fmt.Stringer: 
       fmt.Println(v) 
   default: 
       println("unknown") 
    } 
}

輸出為：

d:100

實現多態功能

多態功能是interface實現的重要功能，也是Golang中的一大行為特色，其多態功能一般要結合Go method實現，作為函數參數可以容易的實現多臺功能。

package main

import "fmt"

// notifier是一個定義瞭通知類行為的接口
type notifier interface {
　 notify()
}

// 定義user及user.notify方法
type user struct {
　 name　string
　 email string
}

func (u *user) notify() {
　 fmt.Printf("Sending user email to %s<%s>\n",
　　　 u.name,
　　　 u.email)
}

// 定義admin及admin.notify方法
type admin struct {
　 name　string
　 email string
}

func (a *admin) notify() {
　 fmt.Printf("Sending admin email to %s<%s>\n",
　　　 a.name,
　　　 a.email)
}

func main() {
　 // 創建一個user值並傳給sendNotification
　 bill := user{"Bill", "[email protected]"}
　 sendNotification(&bill)

　 // 創建一個admin值並傳給sendNotification
　 lisa := admin{"Lisa", "[email protected]"}
　 sendNotification(&lisa)
}

// sendNotification接受一個實現瞭notifier接口的值
// 並發送通知
func sendNotification(n notifier) {
　 n.notify()
}

上述代碼中實現瞭一個多態的例子，函數sendNotification接受一個實現瞭notifier接口的值作為參數。既然任意一個實體類型都能實現該接口，那麼這個函數可以針對任意實體類型的值來執行notify方法，調用notify時，會根據對象的實際定義來實現不同的行為，從而實現多態行為。

補充：interface 與 nil 的比較

引用公司內部同事的討論議題，覺得之前自己也沒有理解明白，為此，單獨羅列出來，例子是最好的說明，如下

package main
 
import (
    "fmt"
    "reflect"
)
 
type State struct{}
 
func testnil1(a, b interface{}) bool {
    return a == b
}
 
func testnil2(a *State, b interface{}) bool {
    return a == b
}
 
func testnil3(a interface{}) bool {
    return a == nil
}
 
func testnil4(a *State) bool {
    return a == nil
}
 
func testnil5(a interface{}) bool {
    v := reflect.ValueOf(a)
    return !v.IsValid() || v.IsNil()
}
 
func main() {
    var a *State
    fmt.Println(testnil1(a, nil))
    fmt.Println(testnil2(a, nil))
    fmt.Println(testnil3(a))
    fmt.Println(testnil4(a))
    fmt.Println(testnil5(a))
}

返回結果如下

false
false
false
true
true

為啥呢？

一個interface{}類型的變量包含瞭2個指針，一個指針指向值的類型，另外一個指針指向實際的值 對一個interface{}類型的nil變量來說，它的兩個指針都是0；但是var a *State傳進去後，指向的類型的指針不為0瞭，因為有類型瞭， 所以比較為false。 interface 類型比較， 要是 兩個指針都相等， 才能相等。

總結

到此這篇關於Go語言中interface語法與使用詳解的文章就介紹到這瞭,更多相關Go語言 interface詳解內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：