Go語言的接口詳解

Posted on by

接口就是一系列方法的集合（規范行為）

在面向對象的領域裡，接口一般這樣定義：接口定義一個對象的行為，規范子類對象的行為。

在 Go 語言中的接口是非侵入式接口（接口沒瞭，不影響代碼），侵入式接口（接口沒瞭，子類報錯）

Go 也是鴨子類型，比如我現在有個鴨子類，內有 speak 方法和 run 方法，子類隻要實現瞭 speak 和 run，我就認為子類是鴨子，我隻要子類中有這兩個方法你就是鴨子，有這兩個方法你就是鴨子，他是從下往上推導隻要有你這裡面的東西，那就是算是繼承瞭你這個接口

1、接口的用途

接口是一個類型

// Duck 定義一個鴨子接口
type Duck interface {
   speak()
   run()
}

// WhiteDuck 定義一個白鴨子結構體
type WhiteDuck struct {
   name  string
   age int
   sex string
}

// BlackDuck 定義一個黑鴨子結構體
type BlackDuck struct {
   name  string
   age int
   sex string
}

// 讓白鴨子和黑鴨子綁定接口中的所有方法，就叫實現該接口
// 讓白鴨子實現 Duck 接口
func (w WhiteDuck) speak() {
   fmt.Println("白鴨子嘎嘎叫，它的名字叫", w.name)
}

func (w WhiteDuck) run() {
   fmt.Println("白鴨子慢悠悠的走，它的名字叫", w.name)
}

// 讓黑鴨子實現 Duck 接口
func (b BlackDuck) speak() {
   fmt.Println("黑鴨子呱呱叫，它的名字叫", b.name)
}

func (b BlackDuck) run() {
   fmt.Println("黑鴨子歪歪扭扭的走，它的名字叫", b.name)
}


func main() {
   var duck Duck
   duck = WhiteDuck{"小白", 15, "男"}	// 把我的對象賦值給一個接口類型，就可以實現多態的效果
   fmt.Println(duck)
    
   // duck 現在他是一個接口，它隻能取方法，不能取出屬性瞭。
   duck.speak()
   duck.run()
}

// 輸出：
{小白 15 男}
白鴨子嘎嘎叫，它的名字叫 小白
白鴨子慢悠悠的走，它的名字叫 小白

2、類型斷言

用於提取接口的底層值，就是把接口類型轉成 struct ，屬性，自有方法也有瞭。

func main() {
	var duck Duck = WhiteDuck{"小白", 15, "男"}
	// 斷言是 WhiteDuck 類型
	value, ok := duck.(WhiteDuck)
	// 斷言成功，ok=true，value就是WhiteDuck結構體對象
	fmt.Println(value)		// 輸出：{小白 15 男}
	fmt.Println(value.name)	// 輸出：小白
	fmt.Println(ok)			// 輸出：true

	// 斷言失敗，ok1=false，value1是BlackDuck類型的空值，因為沒有賦值
	value1, ok1 := duck.(BlackDuck)
	fmt.Println(value1)		// 輸出：{ 0 }
	fmt.Println(ok1)		// 輸出：false
}

3、類型選擇

（通過 Type Switch ）

用於將接口的具體類型與很多 case 語句所指定的類型進行比較。

func main() {
   var duck Duck = WhiteDuck{"小白", 15, "男"}
   test(duck)
}

func test(duck Duck) {
   switch value := duck.(type) {
   case WhiteDuck:
      fmt.Println(value.name)
      fmt.Println("我是白鴨子")
   case BlackDuck:
      fmt.Println(value.name)
      fmt.Println("我是黑鴨子")
   default:
      fmt.Println(value)
      fmt.Println("我是鴨子這個類")
   }
}

4、空接口

沒有任何方法，所有數據類型都實現瞭空接口

type Empty interface {} // 空接口

func main() {
   var a int = 10
   var b string = "XiaoYang"
   var c [3]int
   var e Empty    // e是空接口類型,可以接受任意的數據類型
   e = a
   e = b
   e = c
    
   // 這樣的話需要把它類型選擇回來
   // 正常情況下我隻能接收 Empty 類型的，但是 a b c 都不是 Empty 類型的
   test(a)	// 輸出：我是int 10
   test(b)	// 輸出：我是字符串 XiaoYang
   test(c)	// 輸出：我是數組 [0 0 0]
}

// 如果這不是一個空接口，比如是 Duck 那麼隻要實現瞭 Duck 接口的所有數據類型都可以傳
func test(b Empty)  {		
   switch v:=b.(type) {
   case string:
      fmt.Println("我是字符串", v)
   case int:
      fmt.Println("我是int", v)
   case [3]int:
      fmt.Println("我是數組", v)
   }
}

5、匿名空接口

沒有名字的空接口，一般用在形參上

func main() {
   var duck Duck = WhiteDuck{"小白", 15, "男"}
   test(10)
   test("XiaoYang")
   test(duck)
}

// 這叫匿名空接口，所有數據類型都可以往裡面傳，如果想用原來的結構體還需要類型選擇回來才能用
func test(b interface{}) {
   fmt.Println(b)
}

6、實現多個接口

// Duck 定義一個鴨子接口
type Duck interface {
   speak()
   run()
}

type Animal interface {
   eat()
   sleep()
}

// WhiteDuck 定義一個白鴨子結構體
type WhiteDuck struct {
   name string
   age  int
   sex  string
}


// 讓白鴨子即實現 Duck 接口也實現瞭 Animal 接口
func (w WhiteDuck) speak() {
   fmt.Println("白鴨子嘎嘎叫，它的名字叫", w.name)
}

func (w WhiteDuck) run() {
   fmt.Println("白鴨子慢悠悠的走，它的名字叫", w.name) 
}

func (w WhiteDuck) eat() {
   fmt.Println("白鴨子吃飯，它的名字叫", w.name)
}

func (w WhiteDuck) sleep() {
   fmt.Println("白鴨子睡覺，它的名字叫", w.name)
}


func main() {
	var w WhiteDuck = WhiteDuck{}
	var a Animal
	var d Duck

	// 這樣的話我的 w 即可以給 a ，也可以給 d
	// 但是一旦轉到某個接口上，隻能使用該接口的方法，自身屬性和自身方法需要類型斷言後才能使用
	
	a = w		// w 給瞭 a ，那麼 a 就隻能調用 Animal 接口的方法
	a.sleep()
	a.eat()
	
	d = w		// w 給瞭 d ，那麼 a 就隻能調用 Duck 接口的方法
	d.run()
	d.speak()
}

7、接口嵌套

type Duck interface {
   Animal    // Duck 嵌套 Animal 接口
   speak()
   run()
}

type Animal interface {
   eat()
   sleep()
}

type WhiteDuck struct {
   name string
   age  int
   sex  string
}


// 這樣白鴨子即實現 Duck 接口也實現瞭 Animal 接口
func (w WhiteDuck) speak() {
   fmt.Println("白鴨子嘎嘎叫，它的名字叫", w.name)
}

func (w WhiteDuck) run() {
   fmt.Println("白鴨子慢悠悠的走，它的名字叫", w.name)
}
func (w WhiteDuck) eat() {
   fmt.Println("白鴨子嘎嘎叫，它的名字叫", w.name)
}

func (w WhiteDuck) sleep() {
   fmt.Println("白鴨子慢悠悠的走，它的名字叫", w.name)
}



func main() {
   var a Animal
   var d Duck
   var w WhiteDuck = WhiteDuck{}

   // w 即可以給 a，也可以給 d
   a = w     // 但是 a 隻能調用 Animal 中的兩個方法
   a.sleep()
   a.eat()

   d = w     // d 卻能調用 Duck 和 Animal 中的四個方法
   d.sleep()
   d.eat()
   d.speak()
   d.run()
}

8、接口零值

func main() {

   var a Animal   // nil 就是說明它是一個引用類型
   // 其內部表示就已經告訴瞭我們，它裡面就存兩個值，一個是它的類型，一個是指向具體值的指針

   fmt.Println(a) // 輸出：<nil>
}

9、make和new的區別

type WhiteDuck struct {
   name string
   sex  string
   age  int
}

func main() {
   var per1 *WhiteDuck = new(WhiteDuck) // new 是返回指向這個類型的指針
   // 或者是我取 WhiteDuck 的地址，賦值給 per2
   var per2 = &WhiteDuck{}

   fmt.Println(per1)  // 輸出：&{  0}
   fmt.Println(per2)  // 輸出：&{  0}

   var per3 = make([]int, 3, 4)   // make 是具體的創建引用類型
                           // new 是創建指向這個類型的指針
   var per4 = new([]int)        // 是一個指向切片類型的指針

   fmt.Println(per3)  // 輸出：[0 0 0]
   fmt.Println(per4)  // 輸出：&[]
}

總結

本篇文章就到這裡瞭，希望能夠給你帶來幫助，也希望您能夠多多關註WalkonNet的更多內容！

推薦閱讀：