我們知道 Golang 中沒有 class 的概念，而是通過 interface 型別轉換支援在動態型別語言中常見的 鴨子型別 達到執行時多型的效果。

官方文件 中對 Interface 是這樣定義的：

An interface type specifies a method set called its interface. A variable of interface type can store a value of any type with a method set that is any superset of the interface. Such a type is said to implement the interface. The value of an uninitialized variable of interface type is nil.
 

一個 interface 型別定義了一個 方法集 作為其 介面。 interface 型別的變數可以儲存含有屬於這個 interface 型別方法集超集的任何型別的值，這時我們就說這個型別 實現 了這個 介面。未被初始化的 interface 型別變數的零值為 nil。

對於 interface 型別的方法集來說，其中每一個方法都必須有一個不重複並且不是 補位名（即單下劃線 _）的方法名。

拿 官方文件的例子 來說:

如果我們定義 File 介面型別：

// A simple File interface
type File interface {
    Read(b Buffer
 
) bool
    Write(b Buffer) bool
    Close()
}

那麼，假設有兩個其他型別 S1 和 S2 都擁有下面的方法集：

func (p T) Read(b Buffer) bool { return … }
func (p T) Write(b Buffer) bool { return … }
func (p T) Close() { … }

注意，上面程式碼中的 T 代表 S1 或者 S2。這時，無論 S1 和 S2 各自的方法集中還有哪些方法，我們都說 S1 和 S2 各自 實現 了介面 File。

對於空介面 interface {} 來說，由於其不含有任何方法簽名，在 Golang 語言中我們可以認為所有型別都 實現 了空介面。

一個型別可以 實現 一個或者多個介面，假設我們還有下面的介面型別：

type Locker interface {
    Lock()
    Unlock()
}

而 S1 和 S2 各自的方法集中都含有下面的方法簽名：

func (p T) Lock() { … }
func (p T) Unlock() { … }

同樣的，上面程式碼中的 T 代表 S1 或者 S2，這時我們稱 S1 和 S2 各自都 實現 了介面 File 和 Locker。

一個介面型別（假設為 T）可以 嵌入 另一個介面型別(假設為 E)，這被稱為 embedding interface E in T，而且，所有 E 中的方法都會被新增到 T 中。需要注意的是，一個介面不能 嵌入 其本身，也不能 嵌入 任何已經 嵌入 其本身的其他介面，這樣會造成遞迴 嵌入。

還是通過下面的例子來看看：

package main

import "fmt"

// 定義介面型別 PeopleGetter 包含獲取基本資訊的方法
type PeopleGetter interface {
    GetName() string
    GetAge() int
}

// 定義介面型別 EmployeeGetter 包含獲取薪水的方法
// EmployeeGetter 介面中嵌入了 PeopleGetter 介面，前者將獲取後者的所有方法
type EmployeeGetter interface {
    PeopleGetter
    GetSalary() int
    Help()
}

// 定義結構 Employee
type Employee struct {
    name   string
    age    int
    salary int
    gender string
}

// 定義結構 Employee 的方法
func (self *Employee) GetName() string {
    return self.name
}

func (self *Employee) GetAge() int {
    return self.age
}

func (self *Employee) GetSalary() int {
    return self.salary
}

func (self *Employee) Help() {
    fmt.Println("This is help info.")
}

// 匿名介面可以被用作變數或者結構屬性型別
type Man struct {
    gender interface {
        GetGender() string
    }
}

func (self *Employee) GetGender() string {
    return self.gender
}

// 定義執行回撥函式的介面
type Callbacker interface {
    Execute()
}

// 定義函式型別 func() 的新型別 CallbackFunc
type CallbackFunc func()

// 實現 CallbackFunc 的 Execute() 方法
func (self CallbackFunc) Execute() { self() }

func main() {
    // 空介面的使用，空介面型別的變數可以儲存任何型別的值
    // 空格口型別的變數非常類似於弱型別語言中的變數
    var varEmptyInterface interface{}
    fmt.Printf("varEmptyInterface is of type %T\n", varEmptyInterface)
    varEmptyInterface = 100
    fmt.Printf("varEmptyInterface is of type %T\n", varEmptyInterface)
    varEmptyInterface = "Golang"
    fmt.Printf("varEmptyInterface is of type %T\n", varEmptyInterface)

    // Employee 實現了 PeopleGetter 和 EmployeeGetter 兩個介面
    varEmployee := Employee{
        name:   "Jack Ma",
        age:    50,
        salary: 100000000,
        gender: "Male",
    }
    fmt.Println("varEmployee is: ", varEmployee)
    varEmployee.Help()
    fmt.Println("varEmployee.name = ", varEmployee.GetName())
    fmt.Println("varEmployee.age = ", varEmployee.GetAge())
    fmt.Println("varEmployee.salary = ", varEmployee.GetSalary())

    // 匿名介面物件的使用
    varMan := Man{&Employee{
        name:   "Nobody",
        age:    20,
        salary: 10000,
        gender: "Unknown",
    }}
    fmt.Println("The gender of Nobody is: ", varMan.gender.GetGender())

    // 介面型別轉換，從超集到子集的轉換是可以的
    // 從方法集的子集到超集的轉換會導致編譯錯誤
    // 這種情況下 switch 不支援 fallthrough
    var varEmpInter EmployeeGetter = &varEmployee
    switch varEmpInter.(type) {
    case nil:
        fmt.Println("nil")
    case PeopleGetter:
        fmt.Println("PeopleGetter")
    default:
        fmt.Println("Unknown")
    }

    // 使用 “執行回撥函式的介面物件” 執行回撥函式
    // 這種做法的優勢是函式顯式地 “實現” 特定介面
    varCallbacker := CallbackFunc(func() { println("I am a callback function.") })
    varCallbacker.Execute()

}

將上面的程式碼存入原始檔 interface.go 並使用 go run interface.go 可以看到下面的輸入：

varEmptyInterface is of type <nil>
varEmptyInterface is of type int
varEmptyInterface is of type string
varEmployee is:  {Jack Ma 50 100000000 Male}
This is help info.
varEmployee.name =  Jack Ma
varEmployee.age =  50
varEmployee.salary =  100000000
The gender of Nobody is:  Unknown
PeopleGetter

I am a callback function.

關於 interface 更多需要注意的地方還有：

介面型別不包含任何資料成員。
介面型別進行轉換的時候，預設返回的是臨時物件，所以如果需要對原始物件進行修改，需要獲取原始物件的指標。