介面（interface）定義了一個物件的行為規范，只定義規范不實作，由具體的物件來實作規范的細節，

介面型別

在Go語言中介面（interface）是一種型別，一種抽象的型別，

interface是一組method的集合，是duck-type programming的一種體現，介面做的事情就像是定義一個協議（規則），只要一臺機器有洗衣服和甩干的功能，我就稱它為洗衣機，不關心屬性（資料），只關心行為（方法），

為了保護你的Go語言職業生涯，請牢記介面（interface）是一種型別，

為什么要使用介面

type Cat struct{}

func (c Cat) Say() string { return "喵喵喵" }

type Dog struct{}

func (d Dog) Say() string { return "汪汪汪" }

func main() {
	c := Cat{}
	fmt.Println("貓:", c.Say())
	d := Dog{}
	fmt.Println("狗:", d.Say())
}

上面的代碼中定義了貓和狗，然后它們都會叫，你會發現main函式中明顯有重復的代碼，如果我們后續再加上豬、青蛙等動物的話，我們的代碼還會一直重復下去，那我們能不能把它們當成“能叫的動物”來處理呢？

像類似的例子在我們編程程序中會經常遇到：

比如一個網上商城可能使用支付寶、微信、銀聯等方式去在線支付，我們能不能把它們當成“支付方式”來處理呢？

比如三角形，四邊形，圓形都能計算周長和面積，我們能不能把它們當成“圖形”來處理呢？

比如銷售、行政、程式員都能計算月薪，我們能不能把他們當成“員工”來處理呢？

Go語言中為了解決類似上面的問題，就設計了介面這個概念，介面區別于我們之前所有的具體型別，介面是一種抽象的型別，當你看到一個介面型別的值時，你不知道它是什么，唯一知道的是通過它的方法能做什么，

介面的定義

Go語言提倡面向介面編程，

每個介面由數個方法組成，介面的定義格式如下：

type 介面型別名 interface{
    方法名1( 引數串列1 ) 回傳值串列1
    方法名2( 引數串列2 ) 回傳值串列2
    …
}

其中：

• 介面名：使用type將介面定義為自定義的型別名，Go語言的介面在命名時，一般會在單詞后面添加er，如有寫操作的介面叫Writer，有字串功能的介面叫Stringer等，介面名最好要能突出該介面的型別含義，
• 方法名：當方法名首字母是大寫且這個介面型別名首字母也是大寫時，這個方法可以被介面所在的包（package）之外的代碼訪問，
• 引數串列、回傳值串列：引數串列和回傳值串列中的引數變數名可以省略，

舉個例子：

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

當你看到這個介面型別的值時，你不知道它是什么，唯一知道的就是可以通過它的Write方法來做一些事情，

實作介面的條件

一個物件只要全部實作了介面中的方法，那么就實作了這個介面，換句話說，介面就是一個需要實作的方法串列，

我們來定義一個Sayer介面：

// Sayer 介面
type Sayer interface {
	say()
}

定義dog和cat兩個結構體：

type dog struct {}

type cat struct {}

因為Sayer介面里只有一個say方法，所以我們只需要給dog和cat 分別實作say方法就可以實作Sayer介面了，

// dog實作了Sayer介面
func (d dog) say() {
	fmt.Println("汪汪汪")
}

// cat實作了Sayer介面
func (c cat) say() {
	fmt.Println("喵喵喵")
}

介面的實作就是這么簡單，只要實作了介面中的所有方法，就實作了這個介面，

介面型別變數

那實作了介面有什么用呢？

介面型別變數能夠存盤所有實作了該介面的實體， 例如上面的示例中，Sayer型別的變數能夠存盤dog和cat型別的變數，

func main() {
	var x Sayer // 宣告一個Sayer型別的變數x
	a := cat{}  // 實體化一個cat
	b := dog{}  // 實體化一個dog
	x = a       // 可以把cat實體直接賦值給x
	x.say()     // 喵喵喵
	x = b       // 可以把dog實體直接賦值給x
	x.say()     // 汪汪汪
}

值接收者和指標接收者實作介面的區別

使用值接收者實作介面和使用指標接收者實作介面有什么區別呢？接下來我們通過一個例子看一下其中的區別，

我們有一個Mover介面和一個dog結構體，

type Mover interface {
	move()
}

type dog struct {}

值接收者實作介面

func (d dog) move() {
	fmt.Println("狗會動")
}

此時實作介面的是dog型別：

func main() {
	var x Mover
	var wangcai = dog{} // 旺財是dog型別
	x = wangcai         // x可以接收dog型別
	var fugui = &dog{}  // 富貴是*dog型別
	x = fugui           // x可以接收*dog型別
	x.move()
}

從上面的代碼中我們可以發現，使用值接收者實作介面之后，不管是dog結構體還是結構體指標*dog型別的變數都可以賦值給該介面變數，因為Go語言中有對指標型別變數求值的語法糖，dog指標fugui內部會自動求值*fugui，

指標接收者實作介面

同樣的代碼我們再來測驗一下使用指標接收者有什么區別：

func (d *dog) move() {
	fmt.Println("狗會動")
}
func main() {
	var x Mover
	var wangcai = dog{} // 旺財是dog型別
	x = wangcai         // x不可以接收dog型別
	var fugui = &dog{}  // 富貴是*dog型別
	x = fugui           // x可以接收*dog型別
}

此時實作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{}
	think := "bitch"
	fmt.Println(peo.Speak(think))
}

型別與介面的關系

一個型別實作多個介面

一個型別可以同時實作多個介面，而介面間彼此獨立，不知道對方的實作， 例如，狗可以叫，也可以動，我們就分別定義Sayer介面和Mover介面，如下： Mover介面，

// Sayer 介面
type Sayer interface {
	say()
}

// Mover 介面
type Mover interface {
	move()
}

dog既可以實作Sayer介面，也可以實作Mover介面，

type dog struct {
	name string
}

// 實作Sayer介面
func (d dog) say() {
	fmt.Printf("%s會叫汪汪汪\n", d.name)
}

// 實作Mover介面
func (d dog) move() {
	fmt.Printf("%s會動\n", d.name)
}

func main() {
	var x Sayer
	var y Mover

	var a = dog{name: "旺財"}
	x = a
	y = a
	x.say()
	y.move()
}

多個型別實作同一介面

Go語言中不同的型別還可以實作同一介面 首先我們定義一個Mover介面，它要求必須由一個move方法，

// 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速度70邁\n", c.brand)
}

這個時候我們在代碼中就可以把狗和汽車當成一個會動的物體來處理了，不再需要關注它們具體是什么，只需要呼叫它們的move方法就可以了，

func main() {
	var x Mover
	var a = dog{name: "旺財"}
	var b = car{brand: "保時捷"}
	x = a
	x.move()
	x = b
	x.move()
}

上面的代碼執行結果如下：

旺財會跑
保時捷速度70邁

并且一個介面的方法，不一定需要由一個型別完全實作，介面的方法可以通過在型別中嵌入其他型別或者結構體來實作，

// WashingMachine 洗衣機
type WashingMachine interface {
	wash()
	dry()
}

// 甩干器
type dryer struct{}

// 實作WashingMachine介面的dry()方法
func (d dryer) dry() {
	fmt.Println("甩一甩")
}

// 海爾洗衣機
type haier struct {
	dryer //嵌入甩干器
}

// 實作WashingMachine介面的wash()方法
func (h haier) wash() {
	fmt.Println("洗刷刷")
}

介面嵌套

介面與介面間可以通過嵌套創造出新的介面，

// 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.move()
	x.say()
}

空介面

空介面的定義

空介面是指沒有定義任何方法的介面，因此任何型別都實作了空介面，

空介面型別的變數可以存盤任意型別的變數，

func main() {
	// 定義一個空介面x
	var x interface{}
	s := "Hello 沙河"
	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)
}

空介面的應用

空介面作為函式的引數

使用空介面實作可以接收任意型別的函式引數，

// 空介面作為函式引數
func show(a interface{}) {
	fmt.Printf("type:%T value:%v\n", a, a)
}

空介面作為map的值

使用空介面實作可以保存任意值的字典，

// 空介面作為map值
	var studentInfo = make(map[string]interface{})
	studentInfo["name"] = "沙河娜扎"
	studentInfo["age"] = 18
	studentInfo["married"] = false
	fmt.Println(studentInfo)

型別斷言

空介面可以存盤任意型別的值，那我們如何獲取其存盤的具體資料呢？

介面值

一個介面的值（簡稱介面值）是由一個具體型別和具體型別的值兩部分組成的，這兩部分分別稱為介面的動態型別和動態值，

我們來看一個具體的例子：

var w io.Writer
w = os.Stdout
w = new(bytes.Buffer)
w = nil

請看下圖分解： 

想要判斷空介面中的值這個時候就可以使用型別斷言，其語法格式：

x.(T)

其中：

• x：表示型別為interface{}的變數
• T：表示斷言x可能是的型別，

該語法回傳兩個引數，第一個引數是x轉化為T型別后的變數，第二個值是一個布林值，若為true則表示斷言成功，為false則表示斷言失敗，

舉個例子：

func main() {
	var x interface{}
	x = "Hello 沙河"
	v, ok := x.(string)
	if ok {
		fmt.Println(v)
	} else {
		fmt.Println("型別斷言失敗")
	}
}

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

func justifyType(x interface{}) {
	switch v := x.(type) {
	case string:
		fmt.Printf("x is a string，value is %v\n", v)
	case int:
		fmt.Printf("x is a int is %v\n", v)
	case bool:
		fmt.Printf("x is a bool is %v\n", v)
	default:
		fmt.Println("unsupport type！")
	}
}

因為空介面可以存盤任意型別值的特點，所以空介面在Go語言中的使用十分廣泛，

關于介面需要注意的是，只有當有兩個或兩個以上的具體型別必須以相同的方式進行處理時才需要定義介面，不要為了介面而寫介面，那樣只會增加不必要的抽象，導致不必要的運行時損耗，

練習題

使用介面的方式實作一個既可以往終端寫日志也可以往檔案寫日志的簡易日志庫，

標籤：Go

上一篇：Go語言基礎之反射

下一篇：Go語言基礎之包