Golang學習——interface接口學習（一）

Golang中接口定義及實作，空接口，接口嵌套學習

• 一.接口定義及實作
• • 1.定義接口
  • 2.實作接口
• 二.空接口
• • 1.執行個體
• 三.接口嵌套
• • 1.執行個體

在Golang中，接口是一組方法簽名。當類型為接口中的所有方法提供定義時，它被稱為實作接口。它與

OOP(面向對象程式設計)

非常相似。接口指定了類型應該具有的方法，類型決定了如何實作這些方法。

如果某個對象實作了某個接口的所有方法，則此對象就實作了該接口。

一.接口定義及實作

1.定義接口

關鍵字

interface

用來定義接口，文法如下：

type interface_name interface {
   method_name1([args ...arg_type]) [return_type]
   method_name2([args ...arg_type]) [return_type]
   method_name3([args ...arg_type]) [return_type]
   ...
   method_namen([args ...arg_type]) [return_type]
}
           

一個接口中可以定義多個方法，根據邏輯需要，自定義參數和傳回值。

2.實作接口

一個結構體實作了某個接口的所有方法，則此結構體就實作了該接口。

我們定義一個

Phone

接口，包含兩個方法

call()

和

sendMessage()

type Phone interface {
	call()
	seenMessage()
}
           

聲明結構體，用來實作接口：

type Huawei struct {
	name  string
	price float64
}

type Xiaomi struct {
	name  string
	price float64
}
           

聲明了

Huawei

和

Xiaomi

兩個結構體，各包含

name

和

price

兩個字段。

接下來，實作

Phone

接口，我們先讓

Huawei

結構體實作該接口所有方法：

func (huawei Huawei) call() {
	fmt.Printf("%s 有打電話功能.....\n", huawei.name)
}

func (huawei Huawei) seenMessage() {
	fmt.Printf("%s 有發短信功能.....\n", huawei.name)
}
           

初始化

Huawei

結構體，測試接口的方法：

mate30 := Huawei{
	name:  "Mate 30",
	price: 6999,
}
mate30.call()
mate30.seenMessage()
           

輸出：

Mate 30 有打電話功能.....
Mate 30 有發短信功能.....
           

Huawei

結構體實作了

Phone

接口的所有方法，那就認為，則

Huawei

結構體實作了

Phone

接口。

那如何判斷是否實作了該接口，可參考：

Golang學習——如何判斷Golang接口是否實作？

我們具體也操作下，看看

Xiaomi

結構體若沒有實作

Phone

接口會發生什麼？

實作

Phone

接口一個方法：

func (xiaomi Xiaomi) seenMessage() {
	fmt.Printf("%s 隻有發短信功能.....\n", xiaomi.name)
}
           

Xiaomi

隻實作了

Phone

的 發短信方法，是以認為

Xiaomi

類型未實作了

Phone

接口。我們具體驗證下：

首先初始化

Xiaomi

結構體，并測試方法

xiaomi9 := Xiaomi{
	name:  "Xiao 9",
	price: 4999,
}
xiaomi9.seenMessage()
           

輸出：

seenMessage()

方法測試沒問題，我們使用

new()

函數來測試下

Xiaomi

結構體是否實作了

Phone

接口：

下圖是我從自己的IDE（Goland）截的圖，為了友善記錄，我将上下文的代碼專門換行隔開了。

從圖中可以看到，

new

下方有紅線，滑鼠浮上去會顯示錯誤資訊，大意就是：

Xiaomi

未實作

Phone

接口的某些方法，如：

call()

，是以不能将

Xiaomi

用作電話類型。

二.空接口

空接口

interface{}

：

不包含任何的方法，正因為如此，所有的類型都實作了空接口，是以空接口可以存儲任意類型的數值。

fmt

包下的

Print

系列函數，其參數大多是空接口類型，也可以說支援任意類型：

func Print(a ...interface{}) (n int, err error)
func Println(format string, a ...interface{}) (n int, err error)
func Println(a ...interface{}) (n int, err error)
           

1.執行個體

我們定義一個空接口練習下：

// 定義一個空接口
type Empyt_interface interface {
}

// 定義一個入參為任意類型的函數
func getInfo(arg Empyt_interface) {
	fmt.Println("getInfo 函數.....", arg)
}
// 也可以寫成如下形式，更推薦
func getInfo2(arg interface{}) {
	fmt.Println("getInfo2 函數.....", arg)
}
           

Golang

很多庫的源代碼都會以空接口作為參數，表示接受任意類型的參數

我們自己也實戰一下：

定義一個值為任意類型的

map

map1 := make(map[string] interface{})
map1["數字"] = 1
map1["字元串"] = "字元串"
map1["布爾"] = false
fmt.Println("map1 ...........", map1)
           

輸出：

三.接口嵌套

顧名思義，接口嵌套就是一個接口中包含了其他接口，如果要實作外部接口，那麼就要把内部嵌套的接口對應的所有方法全實作了。

1.執行個體

我們定義3個接口，其中有一個接口嵌套了另外兩個：

// 定義3個接口
type A interface {
	test1()
}

type B interface {
	test2()
}

// 定義嵌套接口
type C interface {
	A
	B
	test3()
}
           

接着我們在定義一個結構體，并實作所有方法：

type Person struct {
	//如果想實作接口C，那不止要實作接口C的方法，還要實作接口A，B中的方法
}

func (p Person) test1() {
	fmt.Println("test1 方法................")
}

func (p Person) test2() {
	fmt.Println("test2 方法................")
}

func (p Person) test3() {
	fmt.Println("test3 方法................")
}
           

初始化結構體，并測試方法：

var person Person = Person{}
// 實作 C 接口的所有方法
person.test1()
person.test2()
person.test3()
           

輸出：

test1 方法................
test2 方法................
test3 方法................
           

以上就是Golang接口的基礎學習，總結了接口的定義及實作，空接口和嵌套接口的概念和使用。