• 接口是一個或多個方法簽名名的集合，定義方式如下
  type Interface_Name interface { method_a() string method_b() int .... }

• 只要某個類型擁有該接口的所有方法簽名，就算實現該接口，無需顯示聲明實現了那個接口，這稱為structural Typing

  package main
  import "fmt"
  
  type USB interface { //定義一個接口：方法的集合
      Name() string //Name方法，返回string
      Connect()     //Connect方法
  }
  
  type PhoneConnecter struct { //定義一個結構
      name string //結構包含一個字段
  }
  
  func (pc PhoneConnecter) Name() string { //為結構定義一個方法，綁定接口
      return pc.name //該方法命名為接口內的字段
  } //返回結構體字段
  
  func (pc PhoneConnecter) Connect() { //定義結構體另一個方法，與接口另一個方法綁定
      fmt.Println("Connect:", pc.name)
  }
  func main() {
      var a USB                            //定義一個變量為USB接口類型
      a = PhoneConnecter{"PhoneConnecter"} //實例化一個結構體，並賦值給變量（接口）USB
      a.Connect()                          //接口調用其Connect方法，也是結構方法
  }
  
  /*輸出
  Connect: PhoneConnecter
  */
   
  

• 接口可以作為匿名嵌入其它接口，或嵌入到結構中

  package main
  import "fmt"
  
  type USB interface { //定義一個接口：方法的集合
      Name() string //Name方法，返回string
      Connecter     //嵌入Connecter接口，可以使用Connecter方法
  }
  
  type Connecter interface { //定義另一個接口 Connecter
      Connect() //包含一個接口方法：Connect
  }
  type PhoneConnecter struct { //定義一個結構
      name string //結構包含一個字段
  }
  
  func (pc PhoneConnecter) Name() string { //為結構定義一個方法，綁定接口
      return pc.name //該方法命名為接口內的字段
  } //返回結構體字段
  
  func (pc PhoneConnecter) Connect() { //定義結構體另一個方法，與接口另一個方法綁定
      fmt.Println("Connect:", pc.name)
  }
  func main() {
      var a USB                            //定義一個變量為USB接口類型
      a = PhoneConnecter{"PhoneConnecter"} //實例化一個結構體，並賦值給變量（接口）USB
      a.Connect()
      Disconnect(a) //接口調用其Connect方法，也是結構方法
  }
   
  

• 接口只是方法聲明，沒有實現調用，沒有字段，只能通過綁定的類型方法訪問

  package main
  import "fmt"
  
  type USB interface { //定義一個接口：方法的集合
      Name() string //Name方法，返回string
      Connecter     //嵌入Connecter接口，可以使用Connecter方法
  }
  
  type Connecter interface { //定義另一個接口 Connecter
      Connect() //包含一個接口方法：Connect
  }
  type PhoneConnecter struct { //定義一個結構
      name string //結構包含一個字段
  }
  
  func (pc PhoneConnecter) Name() string { //為結構定義一個方法，綁定接口
      return pc.name //該方法命名為接口內的字段
  } //返回結構體字段
  
  func (pc PhoneConnecter) Connect() { //定義結構體另一個方法，與接口另一個方法綁定
      fmt.Println("Connected:", pc.name)
  }
  func main() {
      var a USB                     //定義一個變量為USB接口類型
      a = PhoneConnecter{"htc M10"} //實例化一個結構體，並賦值給變量（接口）USB
      a.Connect()
      Disconnect(a) //接口調用其Connect方法，也是結構方法
  }
  
  func Disconnect(usb USB) {
      if pc, ok := usb.(PhoneConnecter); ok { //傳入結構體，判斷賦值是否成功
          fmt.Println("Disconnected:", pc.name)
          return
      }
      fmt.Println("UNknown device.")
  }
  
  /*輸出
  Connect: htc M10
  Disconnect:htc M10
  */
   
  

• go沒有像其他語言繼承，如python中的object表示元類，所有的類都繼承自object類，go通過接口也類似實現了此定義，因為只要某個類型實現了某個接口的方法，我們就說此類實現了
  這個接口。 因為type empty interface{}---空接口沒有任何方法，所以可以理解為所有的接口都實現了空接口的方法（繼承）。

  package main
  import "fmt"
  
  type USB interface { //定義一個接口：方法的集合
      Name() string //Name方法，返回string
      Connecter     //嵌入Connecter接口，可以使用Connecter方法
  }
  
  type Connecter interface { //定義另一個接口 Connecter
      Connect() //包含一個接口方法：Connect
  }
  type PhoneConnecter struct { //定義一個結構
      name string //結構包含一個字段
  }
  
  func (pc PhoneConnecter) Name() string { //為結構定義一個方法，綁定接口
      return pc.name //該方法命名為接口內的字段
  } //返回結構體字段
  
  func (pc PhoneConnecter) Connect() { //定義結構體另一個方法，與接口另一個方法綁定
      fmt.Println("Connected:", pc.name)
  }
  func main() {
      var a USB                     //定義一個變量為USB接口類型
      a = PhoneConnecter{"htc M10"} //實例化一個結構體，並賦值給變量（接口）USB
      a.Connect()
      Disconnect(a) //接口調用其Connect方法，也是結構方法
  }
  
  # func Disconnect(usb interface{}) { //集成空接口，也可以實現
  #   if pc, ok := usb.(PhoneConnecter); ok { //傳入結構體，判斷賦值是否成功
  #       fmt.Println("Disconnected:", pc.name)
  #       return
  #   }
  #   fmt.Println("UNknown device.")
  #   }
  
  //通過switch判斷接口類型：type...switch用法
  func Disconnect(usb interface{}) { //集成空接口，也可以實現
  switch v := usb.(type) {
  case PhoneConnecter:
      fmt.Println("Disconnected:", v.name)
  default:
      fmt.Println("UNknown device.")
  }
  }
  
  /*輸出
  Connect: htc M10
  Disconnect:htc M10
  */

• 接口間的轉換： 只有子類接口可以轉換為父類接口，因為父類接口包含了子類接口，子類接口可以調用父類接口一部分接口方法

• 將對象賦值給接口是，會發生拷貝，而接口內部存儲的是只想這個復制品的指針，也就意味著接口無法修改狀態，也無法獲取指針。

  ...
  func main() {
  pc := PhoneConnecter{"ipad book pro"} //實例化一個結構
  var a Connecter                       //定義a為接口變量
  a = Connecter(pc)                     //接口強制轉換
  a.Connect()
  
  pc.name = "Iphone 7"
  a.Connect()
  ...
  
  /*輸出
  pc.name= "ipad book pro"    Connected: ipad book pro
  pc.name = "Iphone 7"        Connected: ipad book pro
  */
  }

• 只有當 接口存儲的類型和對象都為nil時，接口才等於nil

  package main
  import "fmt"
  
  func main() {
      var a interface{}
      fmt.Println(a == nil)
  
      var p *int = nil
      a = p
      fmt.Println(a == nil)
  }
  
  /*輸出
  true
  false
  */

• 接口調用不會做Receiver的自動轉換

• 接口同樣支持匿名字段的方法

• 接口也可以實現類似OOP(面向對象編程)中的多態

• 空接口可以作為任何類型數據的容器

golang基礎--Interface接口