Go語言之interface

interface 理論

• 接口是一個或多個方法簽名的集合
• 只要某個類型擁有該接口的所有方法簽名，即算實現該接口，無需顯示聲明實現了哪個接口，這稱為Structural Typing
• 接口只有方法聲明，沒有實現，沒有數據字段
• 接口可以匿名嵌入其他接口，或嵌入到結構中
• 將對象賦值給接口時，會發生拷貝，而接口內部存儲的是指向這個復制品的指針，即無法修改復制品的狀態，也無法獲取指針
• 只有當接口存儲的類型和對象都為nil時，接口才等于nil
• 接口調用不會做receiver的自動轉換
• 接口同樣支持匿名字段方法
• 接口也可實現類似OOP中的多態
• 空接口可以作為任務類型數據的容器

  ---

舉例

1、創建接口

// interface 接口  練習
//實現接口的原則就是
//實現了它定義的方法，就默認是實現了接口
package main

import "fmt"

//聲明一個接口
type USB interface {
    //聲明方法Name,  并設置 返回值類型string
    Name() string

    //聲明方法Connect方法，無返回值
    Connect()
}

//聲明一個類型，在Go語言中，對應的就是struct類型
type PhoneConnector struct {
    //聲明一個私有屬性
    name string
}
//---------------------聲明完Name,Connector方法后，就是實現了USB接口了---------------------------
//使用receiver，將類型跟方法進行綁定
func (pc PhoneConnector)Name() string{

    return pc.name
}

func (pc PhoneConnector)Connector()  {
    fmt.Println("connected:\t", pc.name)
}

//--------------------------------------------------------------------------------------
func main() {
    a := PhoneConnector{"apple"}
    fmt.Println("Name:\t", a.Name())
    a.Connector()
}

2、接口之間的嵌套 練習

//interface 嵌套  練習測試
package main

import "fmt"

//定義一個空的接口
//這樣的話，所有的類，都默認實現了這個接口，因為它沒有方法
//定義的空接口，就相當于定義了一 個Object對象，最高層
//都是它的子類了，就沒有任何限制了
type nullEmpty interface {

}

// 定義一個  父接口
type HOME interface {
    //這個接口里，只定義一個方法
    Name() string
}

//再定義一個接口, 這相當于是子接口了
type MyHome interface {
    Show() string
    //這樣就嵌套了 一個接口
    HOME
}

//聲明一個結構類型
type BeijingHome struct {
    name string
}

//-----------開始創建方法method-----
func (info BeijingHome)Show(){
    fmt.Println("Show()--->info.name:\t", info.name)
}

func (info BeijingHome)Name() string{

    return info.name
}

func main() {
    a := BeijingHome{"yihuyuan"}

    fmt.Println("name:\t", a.Name())
    a.Show()

    //------下面演示一下，上面理論中說的---復制品的問題----
    b := a
    b.name = "lenovo" //修改后，并沒有修改a里的值
    b.Show()

    Disconnect(a)
    Disconnect2(a)
}

//設計一個簡單的類型斷言
func Disconnect(home HOME){
    if pc, ok := home.(BeijingHome); ok{
        fmt.Println("Disconnected:\t", pc.name)
        return
    }
    fmt.Println("Unknown decive.")
}

//設計一個簡單的類型斷言
//傳入的參數，是，空接口
//實際上，對于傳入的參數，就沒有限制了
func Disconnect2(home interface{}){
    //對Disconnect()方法，進行改造，
    //因為，傳入的參數是頂層，相當于Java里的Object，沒有任何限制
    //類型，需要自己判斷
    switch v := home.(type) {
    case BeijingHome:
        fmt.Println("Disconnected:\t", v.name)
    default:
        fmt.Println("Unknown decive.")
    }

}

3、不同接口之間的轉換

//不同接口之間的轉換，類似于Java中的向上轉型，或者向下轉型
//就是說，有兩個接口A， B
//其中，A接口里，嵌入了B
//那么A接口可以轉換成B接口，但是，B接口不能轉換成A接口，因為
//A接口里，可能包含B接口里沒有的方法
//也就是說，多的可以向少的轉換，反之不可。
package main

import "fmt"

type USB2 interface {
    Name() string
    Connecter
}

type Connecter interface {
    Connect()
}

type PcConnecter struct {
    name string
}

func (pcConnecter PcConnecter)Name() string {
    return pcConnecter.name
}

func(pcConnecter PcConnecter)Connect() {
    fmt.Println("Connected:\t", pcConnecter.name)
}

func main() {
    pc := PcConnecter{"appleConnector"}
    var a Connecter
    //將USE2 類型，強制 轉換成了Connecter類型
    a = Connecter(pc)
    a.Connect()

    //------驗證----只有當接口存儲的類型和對象都為nil時，接口才等于nil
    //聲明一個空接口, 也沒有賦值，就是nil
    var aa interface{}
    fmt.Println( aa == nil)  // aa 本身就是一個nil,啥也沒存

    //變量p， 是一個指向int類型的指針
    //直接初始化為nil
    var p *int = nil
    aa = p //aa 指向p
    fmt.Println( aa == nil)
}