golang的接口怎么定義使用

這篇文章主要講解了“golang的接口怎么定義使用”，文中的講解內(nèi)容簡單清晰，易于學(xué)習(xí)與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學(xué)習(xí)“golang的接口怎么定義使用”吧！

在golang中，接口是一種類型，是用來將對方法進行一個收束，其作用是：1、作為方法的收束器，進行面向?qū)ο笤O(shè)計；2、作為各種數(shù)據(jù)的承載者，可以用來接收函數(shù)參數(shù)等。接口的定義語法“type 接口類型名 interface{方法名( 參數(shù)列表1 ) 返回值列表}”；當(dāng)方法名首字母是大寫且這個接口類型名首字母也是大寫時，這個方法可以被接口所在的包（package）之外的代碼訪問。

一、接口（interface）是什么

interface是一組method簽名的組合，我們通過interface來定義對象的一組行為。

(注意method 和普通func的區(qū)別)

Interface是一種類型，和往常語言的接口不一樣，它只是用來將對方法進行一個收束。然而正是這種收束，使GO語言擁有了基于功能的面向?qū)ο蟆?/p>

接口的主要功能：

1.作為方法的收束器，進行面向?qū)ο笤O(shè)計。

2.作為各種數(shù)據(jù)的承載者，可以用來接收函數(shù)參數(shù)等。

這也是，GO語言提倡面向接口編程。

二、接口的定義使用

2.1定義

類似結(jié)構(gòu)體

type 接口類型名 interface{
    方法名1( 參數(shù)列表1 ) 返回值列表1
    方法名2( 參數(shù)列表2 ) 返回值列表2
    …
}

當(dāng)然這只是有方法的接口定義，面向數(shù)據(jù)的接口不用。

• 接口名：使用type將接口定義為自定義的類型名。Go語言的接口在命名時，一般會在單詞后面添加er，如有寫操作的接口叫Writer，有字符串功能的接口叫Stringer等。接口名最好要能突出該接口的類型含義。

• 方法名：當(dāng)方法名首字母是大寫且這個接口類型名首字母也是大寫時，這個方法可以被接口所在的包（package）之外的代碼訪問。

• 參數(shù)列表、返回值列表：參數(shù)列表和返回值列表中的參數(shù)變量名可以省略

2.2使用

一個對象只要全部實現(xiàn)了接口中的方法，那么就實現(xiàn)了這個接口。換句話說，接口就是一個需要實現(xiàn)的方法列表。

//定義接口
type FastfoodStore interface{
    MakeHamberger()
    MakeFriedChips()
    MakeSoftDrink()
}
//定義結(jié)構(gòu)體
type KFC struct{}
type HambergerKing struct{}

//實現(xiàn)了接口中所有的方法
func (kfc KFC) MakeHamberger(){
    fmt.println("肯德基的漢堡")
}
func (kfc KFC) MakeFriedChips(){
    fmt.println("肯德基的薯條")
}
func (kfc KFC) MakeSoftDrink(){
    fmt.println("肯德基的飲料")
}

func (K *HambergerKing) MakeHameberger(){
    fmt.println("漢堡王的漢堡")
}
func (K *HambergerKing) MakeFriedChips(){
    fmt.println("漢堡王的薯條")
}
func (K *HambergerKing) MakeSoftDrink(){
    fmt.println("漢堡王的飲料")
}

我們可以看到不同于Java的接口顯式實現(xiàn)，Go的語言是隱式實現(xiàn)的。

• 在 Java 中：實現(xiàn)接口需要顯式地聲明接口并實現(xiàn)所有方法；

• 在 Go 中：實現(xiàn)接口的所有方法就隱式地實現(xiàn)了接口；

那么GO語言是如何檢查該類型是否是接口呢？

答：Go 語言只會在傳遞參數(shù)、返回參數(shù)以及變量賦值時才會對某個類型是否實現(xiàn)接口進行檢查。從類型檢查的過程來看，編譯器僅在需要時才檢查類型，類型實現(xiàn)接口時只需要實現(xiàn)接口中的全部方法，不需要像 Java 等編程語言中一樣顯式聲明。

我們可以看到在上面實現(xiàn)接口的時候，KFC是用結(jié)構(gòu)體對象實現(xiàn)的，而Hamberger king是通過指針實現(xiàn)的兩者有什么不同呢？

答：區(qū)別在于我們初始化接口的時候

//結(jié)構(gòu)體初始化和指針初始化
var f faststore = KFC{}             //可以通過編譯
var f faststore = &KFC{}            //可以通過編譯

var f faststore = HambergerKing{}    //無法通過編譯
var f faststore = &HambergerKing{}    //可以通過編譯

所以在我們使用指針進行實現(xiàn)，結(jié)構(gòu)體初始化時，為啥不行呢？

答：Go 語言在傳遞參數(shù)時都是傳值的。

如上圖所示，無論上述代碼中初始化的變量指針還是結(jié)構(gòu)體，使用 調(diào)用方法時都會發(fā)生值拷貝：

如上圖左側(cè)，對于 &HambergerKing{} 來說，這意味著拷貝一個新的 &HambergerKing{} 指針，這個指針與原來的指針指向一個相同并且唯一的結(jié)構(gòu)體，所以編譯器可以隱式的對變量解引用（dereference）獲取指針指向的結(jié)構(gòu)體；
如上圖右側(cè)，對于 HambergerKing{} 來說，這意味著方法會接受一個全新的 HambergerKing{}，因為方法的參數(shù)是*HambergerKing，編譯器不會無中生有創(chuàng)建一個新的指針；即使編譯器可以創(chuàng)建新指針，這個指針指向的也不是最初調(diào)用該方法的結(jié)構(gòu)體；
上面的分析解釋了指針類型的現(xiàn)象，當(dāng)我們使用指針實現(xiàn)接口時，只有指針類型的變量才會實現(xiàn)該接口；當(dāng)我們使用結(jié)構(gòu)體實現(xiàn)接口時，指針類型和結(jié)構(gòu)體類型都會實現(xiàn)該接口。當(dāng)然這并不意味著我們應(yīng)該一律使用結(jié)構(gòu)體實現(xiàn)接口，這個問題在實際工程中也沒那么重要，在這里我們只想解釋現(xiàn)象背后的原因。

在上面我們說過,interface有兩種用法，現(xiàn)在介紹了其中一種就是作為方法的收束器。那么第二種就是作為數(shù)據(jù)的承載者。

2.3 數(shù)據(jù)承載者

作為數(shù)據(jù)容器時，接口就是一個“空”接口，這個空來形容沒有Method?？読nterface(interface{})不包含任何的method，正因為如此，所有的類型都實現(xiàn)了空interface?？読nterface對于描述起不到任何的作用(因為它不包含任何的method），但是空interface在我們需要存儲任意類型的數(shù)值的時候相當(dāng)有用，因為它可以存儲任意類型的數(shù)值。它有點類似于C語言的void*類型。

需要注意的是，與 C 語言中的 void * 不同，interface{} 類型不是任意類型。如果我們將類型轉(zhuǎn)換成了 interface{} 類型，變量在運行期間的類型也會發(fā)生變化，獲取變量類型時會得到 interface{}。

我們嘗試從底層實現(xiàn)來解釋兩種用法的不同，你會好理解一些。Go 語言使用 runtime.iface 表示第一種接口，使用 runtime.eface 表示第二種不包含任何方法的接口 interface{}，兩種接口雖然都使用 interface 聲明，但是由于后者在 Go 語言中很常見，所以在實現(xiàn)時使用了特殊的類型。

空接口作為函數(shù)的參數(shù)

使用空接口實現(xiàn)可以接收任意類型的函數(shù)參數(shù)。

// 空接口作為函數(shù)參數(shù)
func show(a interface{}) {
    fmt.Printf("type:%T value:%v\n", a, a)
}

空接口作為map的值

使用空接口實現(xiàn)可以保存任意值的字典。

// 空接口作為map值
    var studentInfo = make(map[string]interface{})
    studentInfo["name"] = "Wilen"
    studentInfo["age"] = 18
    studentInfo["married"] = false
    fmt.Println(studentInfo)
//gin框架的gin.H{}

三、關(guān)于接口類型轉(zhuǎn)換

interface 可以存儲所有的值，那么自然會涉及到類型轉(zhuǎn)換這個話題。與此同時，我們也將在這節(jié)細(xì)說類型轉(zhuǎn)換中，因為結(jié)構(gòu)體實現(xiàn)和結(jié)構(gòu)體指針實現(xiàn)的接口的異同。

3.1結(jié)構(gòu)體指針實現(xiàn)接口

//我們?nèi)匀贿\用上面快餐店的例子
type Store interface{
    MakeHamberger()
}
type KFC struct{
    name string
}
func (k *KFC) MakeHamberger(){
    fmt.println(k.name+"制作了一個漢堡")
}
func main(){
    var s store = &KFC{name:"東街店"}
    store.MakeHamberger()
}

這里將上述代碼生成的匯編指令拆分成三部分分析：

1.結(jié)構(gòu)體 KFC 的初始化；

KFC的初始化又可以分為下面幾步：

• 獲取 KFC 結(jié)構(gòu)體類型指針并將其作為參數(shù)放到棧上；

• 通過 CALL 指定調(diào)用 runtime.newobject函數(shù)，這個函數(shù)會以 KFC 結(jié)構(gòu)體類型指針作為入?yún)?，分配一片新的?nèi)存空間并將指向這片內(nèi)存空間的指針返回到 SP+8 上；

• SP+8 現(xiàn)在存儲了一個指向 KFC 結(jié)構(gòu)體的指針，我們將棧上的指針拷貝到寄存器 DI 上方便操作；

• 由于 Cat 中只包含一個字符串類型的 Name 變量，所以在這里會分別將字符串地址 &"東街店" 和字符串長度 6 設(shè)置到結(jié)構(gòu)體上。

2.賦值觸發(fā)的類型轉(zhuǎn)換過程；

因為 KFC 結(jié)構(gòu)體的定義中只包含一個字符串，而字符串在 Go 語言中總共占 16 字節(jié)，所以每一個 KFC 結(jié)構(gòu)體的大小都是 16 字節(jié)。初始化 KFC 結(jié)構(gòu)體之后就進入了將 *KFC 轉(zhuǎn)換成 Store 類型的過程了：

類型轉(zhuǎn)換的過程比較簡單，Store 作為一個包含方法的接口，它在底層使用 [runtime.iface] 結(jié)構(gòu)體表示。runtime.iface 結(jié)構(gòu)體包含兩個字段，其中一個是指向數(shù)據(jù)的指針，另一個是表示接口和結(jié)構(gòu)體關(guān)系的 tab 字段，我們已經(jīng)通過上一段代碼 SP+8 初始化了 KFC 結(jié)構(gòu)體指針，這段代碼只是將編譯期間生成的 runtime.itab 結(jié)構(gòu)體指針復(fù)制到 SP 上：

到這里，我們會發(fā)現(xiàn) SP ~ SP+16 共同組成了 runtime.iface 結(jié)構(gòu)體。

3.調(diào)用接口的方法 Quack()；

棧上的這個 runtime.iface 也是 MakeHamberger() 方法的第一個入?yún)?。通過CALL()完成方法的調(diào)用。

3.2 結(jié)構(gòu)體實現(xiàn)接口

//我們?nèi)匀贿\用上面快餐店的例子
type Store interface{
    MakeHamberger()
}
type KFC struct{
    name string
}
func (k KFC) MakeHamberger(){
    fmt.println(k.name+"制作了一個漢堡")
}
func main(){
    var s store = KFC{name:"東街店"}
    store.MakeHamberger()
}

如果我們在初始化變量時使用指針類型 &KFC{Name: "東街店"} 也能夠通過編譯，不過生成的匯編代碼和上一節(jié)中的幾乎完全相同，所以這里也就不分析這個情況了。

初始化 KFC 結(jié)構(gòu)體；

在棧上初始化 KFC 結(jié)構(gòu)體，而上一節(jié)的代碼在堆上申請了 16 字節(jié)的內(nèi)存空間，棧上只有一個指向 KFC 的指針。

完成從 KFC 到 Store 接口的類型轉(zhuǎn)換；

初始化結(jié)構(gòu)體后會進入類型轉(zhuǎn)換的階段，編譯器會將 go.itab."".KFC,"".Store 的地址和指向 KFC 結(jié)構(gòu)體的指針作為參數(shù)一并傳入 runtime.convT2I 函數(shù)：這個函數(shù)會獲取 runtime.itab 中存儲的類型，根據(jù)類型的大小申請一片內(nèi)存空間并將 elem 指針中的內(nèi)容拷貝到目標(biāo)的內(nèi)存中：

func convT2I(tab *itab, elem unsafe.Pointer) (i iface) {
    t := tab._type
    x := mallocgc(t.size, t, true)
    typedmemmove(t, x, elem)
    i.tab = tab
    i.data = x
    return
}

runtime.convT2I 會返回一個 runtime.iface，其中包含 runtime.itab 指針和 KFC 變量。當(dāng)前函數(shù)返回之后，main 函數(shù)的棧上會包含以下數(shù)據(jù)：

SP 和 SP+8 中存儲的 runtime.itab 和 KFC 指針是 runtime.convT2I 函數(shù)的入?yún)?，這個函數(shù)的返回值位于 SP+16，是一個占 16 字節(jié)內(nèi)存空間的 runtime.iface 結(jié)構(gòu)體，SP+32 存儲的是在棧上的 KFC 結(jié)構(gòu)體，它會在 runtime.convT2I 執(zhí)行的過程中拷貝到堆上。

3.3類型斷言

如何將一個接口類型轉(zhuǎn)換成具體類型？

x.(T)

非空接口

func main() {
    var c Store = &KFC{Name: "東街店"}
    switch c.(type) {
    case *KFC:
        kfc := c.(*KFC)
        kfc.MakeHamberger()
    }
}

因為 Go 語言的編譯器做了一些優(yōu)化，所以代碼中沒有runtime.iface 的構(gòu)建過程，不過對于這一節(jié)要介紹的類型斷言和轉(zhuǎn)換沒有太多的影響。

switch語句生成的匯編指令會將目標(biāo)類型的 hash 與接口變量中的 itab.hash 進行比較

空接口

func main() {
    var c interface{} = &KFC{Name: "東街店"}
    switch c.(type) {
    case *KFC:
        kfc := c.(*KFC)
        kfc.MakeHamberger()
    }
}

上述代碼會在類型斷言時就不是直接獲取變量中具體類型的 runtime._type，而是從 eface._type 中獲取，匯編指令仍然會使用目標(biāo)類型的 hash 與變量的類型比較.

感謝各位的閱讀，以上就是“golang的接口怎么定義使用”的內(nèi)容了，經(jīng)過本文的學(xué)習(xí)后，相信大家對golang的接口怎么定義使用這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關(guān)知識點的文章，歡迎關(guān)注！