概述

如何理解 interface ?

1. 1. interface 是方法聲明的集合
2. 2. 某個類型實現了 interface 中聲明的全部方法，表明該類型實現了該接口
3. 3. interface 可以作為一種數據類型，實現了該接口的任何類型都可以賦值給該接口類型變量

Go 語言是松耦合的類型、方法對接口的實現，雖然沒有面向對象編程語言中 類 的概念，但是面向對象的三大特性 封裝、繼承、多態, 在 Go 中同樣可以實現。

下面來逐個介紹。

封裝

Go 將訪問層次簡化為兩層 :

• ? 不可導出: 通過標識符首字母小寫，對象 僅包內可見
• ? 可導出: 通過標識符首字母大寫，對象 對所有包可見

例子

不可導出

Person 類型及方法只能在 foo 包中使用。

package foo

type person interface {
    name() string
    age() int
}

可導出

Person 類型及方法可以在所有包中使用。

package foo

type Person interface {
    Name() string
    Age() int
}

繼承

通過組合實現，當一個類型 A 內嵌另一個類型 B 的值或指針時，類型 A 可以使用類型 B 的所有方法，通過內嵌多個類型，可以達到 多重繼承 的效果。

例子

單個繼承

package main

import (
    "log"
    "os"
)

type Person struct {
    Name        string
    Age         int
    *log.Logger // 等于繼承了 log.Logger 的所有方法 
}

func main() {
    tom := Person{
        Name:   "Tom",
        Age:    6,
        Logger: log.New(os.Stdout, "", 0),
    }

    tom.Printf("My name is %s, age is %d", tom.Name, tom.Age)
}

$ go run main.go
# 輸出如下 
My name is Tom, age is 6

在上面的示例代碼中，Person 通過內嵌 log.Logger 類型 "繼承" 了 Printf Fatal 等方法。

多重繼承

package main

import (
    "log"
    "os"
    "sync"
)

type Person struct {
    Name        string
    Age         int
    *log.Logger // 等于繼承了 log.Logger 的所有方法
    *sync.Mutex // 等于繼承了 sync.Mutex 的所有方法
}

func main() {
    tom := Person{
        Name:   "Tom",
        Age:    6,
        Logger: log.New(os.Stdout, "", 0),
        Mutex:  &sync.Mutex{},
    }

    tom.Lock()
    tom.Printf("My name is %s, age is %d", tom.Name, tom.Age)
    tom.Unlock()
}

$ go run main.go
# 輸出如下 
My name is Tom, age is 6

在上面的示例代碼中，Person 通過內嵌 log.Logger 類型和 sync.Mutex 類型， "繼承" 了兩者所有的方法， 如 Printf Fatal Lock Unlock 等。

重載

Go 不支持重載操作。

重寫

通過 定義同名方法 實現，當一個類型 A 內嵌另一個類型 B 的值或指針時，類型 A 可以重新聲明并定義類型 B 的所有方法，可以達到 重寫 的效果。

package main

import (
    "log"
    "os"
)

type Person struct {
    Name        string
    Age         int
    *log.Logger // 等于繼承了 log.Logger 的所有方法
}

// 重寫 Logger 的 Printf 方法
func (p *Person) Printf(format string, v ...any) {
    println("hello world")
}

func main() {
    tom := Person{
        Name:   "Tom",
        Age:    6,
        Logger: log.New(os.Stdout, "", 0),
    }

    // 輸出 hello world
    tom.Printf("My name is %s", tom.Name)

    // 輸出 hello world
    tom.Printf("My age is %d", tom.Age)
}

$ go run main.go
# 輸出如下 
hello world
hello world

在上面的示例代碼中，Person 通過內嵌 log.Logger "繼承" 了 log.Logger 的所有方法，同時又重寫了 Printf 方法，重寫之后， 調用 Printf 方法時，不論參數是什么，都只會輸出 hello world。

多態

通過接口實現， 某個類型的實例可以賦值給它所實現的任意接口類型的變量 。每個模塊不需要了解其他模塊的的細節， A 模塊定義接口，B 模塊實現接口就可以，如果接口中沒有使用到 A 模塊中定義的數據類型，那么 B 模塊中都不需要 import A, 也就是 接口定義方和接口實現方不需要建立 import 聯系， 非常優秀地實現了接口設計的 正交性。

例子

標準庫的 io.Writer 接口

package io

type Writer interface {
    Write(p []byte) (n int, err error)
}

上面是標準庫中的 io.Writer 接口，我們可以在自己的模塊中實現它:

package main

type MyBuffer struct{} // 定義時并不需要 import "io"

func (m MyBuffer) Write(p []byte) (n int, err error) {
    return 0, nil
}

然后，在使用 io.Writer 類型作為參數的函數或方法中，可以直接傳入 MyBuffer 類型，比如 log 包的 SetOutput 方法:

package log

func SetOutput(w io.Writer) {
    output = w
}

上述代碼中，通過接口規則，非常優雅地實現了 接口的具體實現與解耦。在 Go 的標準庫中，更是將上述準則應用到幾乎所有 Go 包， 多態用得越多，代碼就相對越少 。這被認為是 Go 編程最佳實踐之一。

正交性的小問題

一個代碼量龐大且結構復雜的項目中，會有很多 接口，例如 ORM 框架針對不同數據庫的連接接口，我們希望知道該接口被哪些類型實現了, 反過來，針對一個具體的類型，我們希望知道它實現了哪些接口。這個常用的功能，貌似只有 Goland 實現了。

小結

本小節概括了 Go 語言的 面向對象 特性以及如何使用。封裝 通過首字母大小寫區分，不需要 public private protected 等關鍵字，繼承 通過類型嵌套實現，直接從語法層面踐行了 組合優于繼承 的理念，多態 通過接口實現，從語法層面將接口定義方和接口實現方解耦， 實現了優秀的 正交性 設計。

在開發過程中，可以直接添加新接口， 已有的接口無需改動，已有的類型只需實現新接口的方法即可 ， 對于已有的函數，可以將函數參數類型擴展成使用 接口類型 的約束性參數。整個系統設計可以持續演進，而不用推翻之前的方案。在代碼層面，不需要像基于 類 的面向對象語言一樣，維護和適應 整個類層次結構 的變化。

擴展閱讀

Go 和 Java 接口差異

侵入性

Java 語言中的接口是強制性的，類 必須聲明實現了某個接口，并實現該接口的所有方法，這種機制被稱為 侵入式 接口。

Go 語言中接口核心理念是 組合，而且接口定義方和接口實現方以原生方式解耦，擴展性更強，這種機制被成為 非侵入式 接口。一個類型只需要實現接口定義的所有方法，那么該類型就自動實現了接口，這種方式屬于 隱式實現 而非 顯式聲明。

類型能做什么比類型是什么更重要。

Go 接口設計思想

Go 結合了 接口值，編譯器靜態類型檢查（該類型是否實現了某個接口），運行時動態轉換，并且不需要 顯式地聲明 類型要實現某個接口。這個特性可以在不修改已有代碼的情況下定義和實現新接口，從而提供了 動態語言 的優點，但卻沒有 動態語言 在運行時可能發生錯誤的問題。