Golang的接口介紹

本文以Golang的接口實現為例，為大家分析Golang接口功能與作用。閱讀完整文相信大家對Golang的接口有了一定的認識。

1.1接口類型

在Go語言中，接口(interface)是一種類型，一種抽象的類型。
interface是一組method的集合，是duck-type programming的一種體現。
接口做的事情就像是定義一個協議(規則)，只要一臺機器有洗衣服和甩干的功能，就是洗衣機。不關心屬性(數據)，只關心行為(方法)。
在Java中，也是有接口的概念的。

1.2為什么要使用接口

package main

import "fmt"

type Cat struct {}

func (c Cat) say() string  {
    return "喵喵喵"
}
type Dog struct {}

func (d Dog) say() string {
    return "汪汪汪"
}
func main()  {
    var c Cat
    fmt.Println("貓：",c.say())

    var d Dog
    fmt.Println("狗：",d.say())
}

結果：
貓： 喵喵喵
狗： 汪汪汪

Process finished with exit code 0

上面的代碼中定義了貓和狗，都會叫，你會發現main函數中有明顯的代碼重復，如果動物越多，那么say()函數會越多，那怎樣優化呢？
可以使用接口！

1.3接口的定義

Go語言提倡面向接口編程。
每個接口由數個方法組成，接口的定義格式如下：

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

其中：
接口名：使用type將接口定義為自定義的類型名。
    Go語言的接口在命名時，一般會在單詞后面添加er,如有寫操作的接口叫Writer,有字符串功能的接口叫Stringer等。
    接口名最好要能突出該接口的類型含義。
方法名：當方法名首字母是大寫且這個接口類型名首字母是大寫時，這個方法可以被接口所在的包(package)之外的代碼訪問。
參數列表、返回值列表：參數列表和返回值列表中的參數變量名可以省略。

例如：
type writer interface{
    Write([]byte) error
}

當看到這個接口類型的值時i，不知道它是什么，唯一知道的就是通過它的Writer方法來做一些事情。

1.4實現接口的條件

一個對象只要全部實現了接口中的方法，那么就實現了這個接口。即接口就是一個需要實現的方法列表。

package main

import "fmt"

//定義一個Sayer接口
type Sayer interface {
    say()
}

//定義dog和cat兩個結構體
type dog struct {}
type cat struct {}
//因為Sayer接口中只有一個say方法，所以我們只需要給dog和cat分別實現say()方法，就能實現Sayer接口了。
func (d dog) say()  {
    fmt.Println("汪汪汪")
}
func (c cat) say()  {
    fmt.Println("喵喵喵")
}
//接口實現就是這樣，只要實現了接口中的所有方法，就實現了這個接口。
func main()  {
    var d dog
    var c cat
    d.say()
    c.say()
}

結果：
汪汪汪
喵喵喵

Process finished with exit code 0

1.5接口類型變量

那么實現了接口有什么用呢？
接口類型變量能夠存儲所有實現了該接口的實例。
例如上面的示例中，Sayer類型的變量能夠存儲dog和cat類型的變量。

package main

import "fmt"

//定義一個Sayer接口
type Sayer interface {
    say()
}

//定義dog和cat兩個結構體
type dog struct {}
type cat struct {}
//因為Sayer接口中只有一個say方法，所以我們只需要給dog和cat分別實現say()方法，就能實現Sayer接口了。
func (d dog) say()  {
    fmt.Println("汪汪汪")
}
func (c cat) say()  {
    fmt.Println("喵喵喵")
}
//接口實現就是這樣，只要實現了接口中的所有方法，就實現了這個接口。
func main()  {
    var x Sayer //聲明一個Sayer類型的變量x
    c := cat{}  //實例化一個cat
    d := dog{}  //實例化一個dog
    x = c       //可以吧cat示例直接賦值給x
    x.say()     //喵喵喵
    x = d       //可以吧dog實力直接賦值給x
    x.say()     //汪汪汪
}

結果：
喵喵喵
汪汪汪

Process finished with exit code 0

1.6值接收者和指針接收者實現接口的區別

使用值接收者實現接口和使用指針接收者實現接口有什么區別呢？看一下下面的例子

值接收者實現接口

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()
}

結果：
狗會動！
狗會動！

Process finished with exit code 0

從上面的代碼中我們可以發現，使用值接收者實現接口侯，不管是dog結構體還是結構體指針*dog類型的變量，都可以賦值給改接口變量。
因為Go語言中有對指針類型變量求值的語法糖，dog指針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類型，直接報錯
    x.move()

    var fugui = &dog{}  //富貴是*dog類型
    x = fugui           //x可以接收*dog類型
    x.move()
}

此時實現Mover接口的是*dog類型，所以不能給x傳入dog類型的wangcai，此時x只能存儲*dog類型的值。

面試題

首先請觀察下面的這段代碼，然后請回答這段代碼能不能通過編譯？

type People interface {
    Speak(string) string
}

type Student struct{}

func (stu *Student) Speak(think string) (talk string) {
    if think == "sb" {
        talk = "你是個大帥哥"
    } else {
        talk = "您好"
    }
    return
}

func main() { 
    var peo People = Student{}  //不能通過編譯，這里要變為var peo People = &Student{}
    think := "思考"
    fmt.Println(peo.Speak(think))
}

1.7類型與接口的關系

1.7.1一個類型實現多個接口

一個類型可以同時實現多個接口，而接口間，彼此是獨立的，不知道對方的實現。
例如，狗可以叫，也可以動。我們可以分別定義Sayer接口和Mover接口。

package main

import "fmt"

type Mover interface {
    move()
}
type Sayer interface {
    say()
}
type dog struct {
    name string
}
//實現Mover接口
func (d dog) move()  {
    fmt.Printf("%s狗會動！\n",d.name)
}
//實現Sayer接口
func (d dog) say()  {
    fmt.Printf("%s狗會叫！\n",d.name)
}
func main()  {
    var x Sayer
    var y Mover

    //dog既可以實現Sayer接口，也可以實現Mover接口
    var a = dog{name:"旺財"}
    x = a
    y = a
    x.say()
    y.move()
}

結果：
旺財狗會叫！
旺財狗會動！

Process finished with exit code 0

1.7.2多個類型實現同一個接口

package main

import "fmt"
//Go語言中不同的類型可以實現同一個接口，首先定義一個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)
}
//這時候就可以在代碼中把狗和汽車當成一個會動的物體來處理，不需要關注它們具體是什么，只需要調用它們的move方法就可以了。
func main()  {
    var x Mover

    //dog既可以實現Sayer接口，也可以實現Mover接口
    var a = dog{name:"旺財"}
    var b = car{brand:"寶馬"}
    x = a
    x.move()
    x = b
    x.move()
}

結果：
旺財狗會動！
寶馬小車會跑！

Process finished with exit code 0

一個接口的方法，不一定需要由一個類型完全實現，接口的方法可以通過在類型中嵌入其他類型或結構體來實現。

package main

import "fmt"

//洗衣機接口
type WashingMachine interface {
    wash()
    dry()
}
//甩干器
type dryer struct {}
//海爾洗衣機
type haier struct {
    dryer //嵌入甩干器
}

//實現WashingMachine接口的dry()方法
func (d dryer) dry()  {
    fmt.Println("甩一甩")
}
//實現WashingMachine接口的wash()方法
func (h haier) wash()  {
    fmt.Println("wash")
}
func main()  {
    var d dryer
    var h haier
    d.dry()
    h.wash()
    h.dry()

}

結果：
甩一甩
wash
甩一甩

Process finished with exit code 0

1.8接口嵌套

接口與接口之間可以通過嵌套創造出新的接口。

package main

import "fmt"

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

//接口嵌套
type animal interface {
    Sayer
    Mover
}
//嵌套得到的接口的使用與普通接口一樣，這里讓cat實現animal接口：
type cat struct {
    name string
}

func (c cat) say()  {
    fmt.Println("喵喵喵")
}
func (c cat) move()  {
    fmt.Println("貓會動")
}
func main()  {
    var x animal
    x = cat{name:"花花"}
    x.say()
    x.move()
}

結果：
喵喵喵
貓會動

Process finished with exit code 0

1.9空接口

1.9.1空接口的定義

空接口是指沒有定義任何方法的接口。因此任何類型都實現了空接口。
空接口類型的變量可以存儲任意類型的變量。

package main

import "fmt"

func main()  {
    var x interface{}
    s := "hello vita"
    x = s
    fmt.Printf("type:%T value:%v\n",x,x)
    i := 100
    x = i
    fmt.Printf("type:%T value:%v\n",x,x)
    b := true
    x = b
    fmt.Printf("type:%T value:%v\n",x,x)
}

結果：
type:string value:hello vita
type:int value:100
type:bool value:true

Process finished with exit code 0

1.9.2空接口的應用

空接口作為函數的參數

使用空接口實現可以接收任意類型的函數參數。

package main

import "fmt"

func show(x interface{})  {
    fmt.Printf("type:%T value:%v\n",x,x)
}
func main()  {
    show("hello vita")
    show(100)
    show(true)
}

結果：
type:string value:hello vita
type:int value:100
type:bool value:true

Process finished with exit code 0

空接口作為map的值

使用空接口，可以實現map的value是任意值。

package main

import "fmt"

func main()  {
    var studentInfo = make(map[string]interface{})
    studentInfo["name"] = "vita"
    studentInfo["age"] = 18
    studentInfo["married"] = true
    fmt.Println(studentInfo)
}

結果：
map[age:18 married:true name:vita]

Process finished with exit code 0

1.10類型斷言

1.10.1接口值

空接口可以存儲任意類型的值，那我們如何獲取其存儲的具體數據呢？

接口值：
一個接口的值（簡稱接口值）是由一個"具體類型"和"具體類型的值"兩部分組成，這兩部分分別稱為接口的"動態類型"和"動態值"。

看下面的例子：
var w io.Writer
w = os.Stdout
w = new(bytes.Buffer)
w = nil

1.10.2斷言

想要判斷空接口中的值，這時候可以使用類型斷言，語法格式為：
x.(T)
其中：
x：表示類型為interface{}的變量
T：表示斷言x可能是的類型
該語法返回兩個參數，第一個參數是x轉化為T類型后的變量，第二個值是一個布爾值，若為true則表示斷言成功，為false表示斷言失敗。

package main

import "fmt"

func main()  {
    var x interface{}
    x = "hello vita"
    v,ok := x.(string)
    if ok{
        fmt.Println(v)
    }else{
        fmt.Println("類型不是string")
    }
}

結果：
hello vita

Process finished with exit code 0

上面的實例中，如果要斷言多次就要寫多個if判斷，這個時候我們可以使用switch語句來實現：

package main

import "fmt"

func main()  {
    var x interface{}
    x= "hello"
    switch v := x.(type) {
    case string:
        fmt.Printf("x是string類型，value is %v\n",v)
    case int:
        fmt.Printf("x是int類型，value is %v\n",v)
    case bool:
        fmt.Printf("x是bool類型，value is %v\n",v)
    }
}

結果：
x是string類型，value is hello

Process finished with exit code 0

以上就是Golang接口的詳細內容了，看完之后是否有所收獲呢？如果想了解更多相關內容，歡迎關注億速云行業資訊！