2020-10-18Go語言介面

介面定義

在Golang中介面（interface）是一種型別，一種抽象的型別。介面（interface）是一組函式method的集合，Golang中的介面不能包含任何變數。任何其他型別只要實現了這些method方法就是實現了這個介面。

在Golang中介面的所有方法都沒有方法體，介面定義了一個物件的行為規範，只定義規範不實現。介面體現了程式設計的多型和高內聚低耦合的思想。

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

type 介面名 interface {
    方法名1 (引數列表1) 返回值列表1
    方法名2 (引數列表2) 返回值列表2
}

• 介面名：使用type關鍵字宣告，命名時已辦會在單詞後面新增er 例如 Writer、Stringer，介面名最好能突出介面型別含義
• 方法名：當方法名首字母大寫且這個介面型別名首字母也是大寫時，這個方法可以被介面所在的包之外的程式碼訪問

舉例：

package main

import "fmt"

//定義Usber介面
type Usber interface {
	start()
	stop()
}

//定義Phone介面體
type Phone struct {
	Name string
}

//Phone實現介面方法
func (p Phone) start() {
	fmt.Println(p.Name, "啟動")
}

func (p Phone) stop() {
	fmt.Println(p.Name, "關閉")
}

func main() {
	phone := Phone{Name: "華為手機P40"}
	phone.start()
	phone.stop()

	var usber1 Usber
	usber1 = Phone{Name: "蘋果手機XMax"}
	usber1.start()
	usber1.stop()

}

---

空介面

Golang 中的介面可以不定義任何方法，沒有定義方法的介面就是空介面。空介面標識沒有任何約束，因此任何型別變數都可以實現空介面，空介面在實際專案中用的是非常多的，用空介面可以表示任意資料型別。

例如：

package main

import "fmt"

//定義空介面
type EmptyA interface {
}

func main() {
	var a EmptyA
	a = "你好 Golang"
	fmt.Println(a)
}

同時golang中空介面也可以直接當做型別來使用，可以表示任意型別。相當於Java中的Object型別

	var b interface{}
	b = 20
	fmt.Println(b)
	b = true
	fmt.Println(b)
	b = 3.1415926
	fmt.Println(b)

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

package main

import "fmt"


func show( i interface{})   {
	fmt.Println(i)
}

func main() {
	show("hello world")
}

map的值實現空介面

// 定義一個值為空介面型別
var studentInfo = make(map[string]interface{})
studentInfo["userName"] = "張三"
studentInfo["age"] = 15
studentInfo["isWork"] = true

slice切片實現空介面

 

// 定義一個空介面型別的切片
var slice = make([]interface{}, 4, 4)
slice[0] = "張三"
slice[1] = 1
slice[2] = true

---

型別斷言

一個介面的值是由一個具體型別和具體型別的值兩部分組成。這兩部分分別成為介面的動態型別和動態值。如果我們想要判斷介面中值的型別，那麼這時候就可以使用型別斷言，語法如下：

x.(T)

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

該語法返回兩個引數，第一個引數是 x 轉化為 T型別後的變數，第二個是布林值，true 標識斷言成功，反之失敗

示例：

	var inter interface{}
	inter = "weizhouck"
	value, isString := inter.(string)
	fmt.Println(value, isString)

	Print(100)
	Print("100")
	Print(100.12)

func Print(x interface{}) {
	if _, isString := x.(string); isString {
		fmt.Println("傳入引數是string型別")
	} else if _, isInt := x.(int); isInt {
		fmt.Println("傳入引數是int型別")
	} else {
		fmt.Println("傳入其它型別")
	}
}

func Print2(x interface{})  {
	switch x.(type) {
	case int:
		fmt.Println("int型別")
	case string:
		fmt.Println("string型別")
	case bool:
		fmt.Println("bool型別")
	default:
		fmt.Println("其它型別")
	}
}

---

結構體實現多個介面

實現多個介面的話，可以同事使用兩個介面進行結構體接受

// 定義一個Animal的介面，Animal中定義了兩個方法，分別是setName 和 getName，分別讓DOg結構體和Cat結構體實現
type Animal interface {
	SetName(string)
}

// 介面2
type Animal2 interface {
	GetName()string
}

type Dog struct {
	Name string
}

func (d *Dog) SetName(name string)  {
	d.Name = name
}
func (d Dog)GetName()string {
	return d.Name
}

func main() {
	var dog = &Dog{
		"小黑",
	}
	// 同時實現兩個介面
	var d1 Animal = dog
	var d2 Animal2 = dog
	d1.SetName("小雞")
	fmt.Println(d2.GetName())
}

---

介面巢狀

在 Golang 中，允許介面巢狀介面，我們首先建立一個 Animal1和 Animal2,然後使用 Animal接收剛剛的兩個介面

package main

import "fmt"

type Animal1 interface {
	SetName(string)
}

type Animal2 interface {
	GetName() string
}

type Animal interface {
	Animal1
	Animal2
}
type Dog struct {
	Name string
}

func (d *Dog) SetName(name string) {
	d.Name = name
}
func (d Dog) GetName() string {
	return d.Name
}
func main() {
	var dog = &Dog{
		"小黑",
	}
	fmt.Println(dog.GetName())

	// 同時實現兩個介面
	var d Animal = dog
	d.SetName("小雞")
	fmt.Println(d.GetName())
}

---

Golang中空介面和型別斷言

// golang中空介面和型別斷言
	var userInfo = make(map[string]interface{})
	userInfo["userName"] = "zhangsan"
	userInfo["age"] = 10
	userInfo["hobby"] = []string{"吃飯", "睡覺"}
	fmt.Println(userInfo["userName"])
	fmt.Println(userInfo["age"])
	fmt.Println(userInfo["hobby"])
	// 但是我們空介面如何獲取陣列中的值？發現 userInfo["hobby"][0]  這樣做不行
	// fmt.Println(userInfo["hobby"][0])
	// 這個時候我們就可以使用型別斷言了
	hobbyValue,ok := userInfo["hobby"].([]string)
	if ok {
		fmt.Println(hobbyValue[0])
	}

通過型別斷言返回來的值，我們就能夠直接通過角標獲取了。