Go类型嵌入介绍和使用类型嵌入模拟实现“继承”
Go類型嵌入介紹和使用類型嵌入模擬實現“繼承”
目錄-
Go類型嵌入介紹和使用類型嵌入模擬實現“繼承”
- 一、獨立的自定義類型
- 二、繼承
-
三、類型嵌入
- 3.1 什么是類型嵌入
-
四、接口類型的類型嵌入
- 4.1 接口類型的類型嵌入介紹
- 4.2 一個小案例
-
五、結構體類型的類型嵌入
- 5.1 結構體類型的類型嵌入介紹
- 5.2 小案例
- 六、“實現繼承”的原理
-
七、類型嵌入與方法集合
- 7.1 結構體類型中嵌入接口類型
- 7.2 結構體類型中嵌入結構體類型
-
八、defined 類型與 alias 類型是否可以實現方法集合的“繼承”？
- 8.1 defined 類型與 alias 類型的方法集合
- 九、小結
一、獨立的自定義類型
什么是獨立的自定義類型呢？就是這個類型的所有方法都是自己顯式實現的。
我們舉個例子，自定義類型 T 有兩個方法 M1 和 M2，如果 T 是一個獨立的自定義類型，那我們在聲明類型 T 的 Go 包源碼文件中一定可以找到其所有方法的實現代碼，比如：
func (T) M1() {...}
func (T) M2() {...}
難道還有某種自定義類型的方法不是自己顯式實現的嗎？當涉及到 Go 語言中的自定義類型時，有一種方法可以不需要顯式地實現方法，即：讓某個自定義類型“繼承”其他類型的方法實現。
二、繼承
Go 語言從設計伊始，就決定不支持經典面向對象的編程范式與語法元素，所以我們這里只是借用了“繼承”這個詞匯而已，說是“繼承”，實則依舊是一種組合的思想。
這種“繼承”是通過 Go 語言的類型嵌入（Type Embedding）來實現的。
三、類型嵌入
3.1 什么是類型嵌入
類型嵌入指的就是在一個類型的定義中嵌入了其他類型。Go 語言支持兩種類型嵌入，分別是接口類型的類型嵌入和結構體類型的類型嵌入。
四、接口類型的類型嵌入
4.1 接口類型的類型嵌入介紹
接口類型的類型嵌入是指在一個接口類型的定義中嵌入其他接口類型，從而使接口類型包含了嵌入接口中定義的方法。這允許一個接口類型繼承另一個接口類型的方法集，以擴展其功能。
總結接口類型的類型嵌入的關鍵點：
- 嵌入接口類型：接口類型可以嵌入其他接口類型，將其方法集合并到當前接口中。
- 繼承方法集：通過嵌入，接口類型可以繼承嵌入接口中的方法，使得當前接口也具有這些方法。
- 實現多態：通過接口類型的類型嵌入，可以實現多態，使不同類型的對象可以被統一地處理，提高代碼的靈活性。
這種機制使得Go語言的接口更加靈活和可擴展，允許將不同的接口組合在一起，以創建更復雜的接口，從而促進了代碼的重用和可維護性。
4.2 一個小案例
接著，我們用一個案例，直觀地了解一下什么是接口類型的類型嵌入。我們知道，接口類型聲明了由一個方法集合代表的接口，比如下面接口類型 E：
type E interface {
M1()
M2()
}
這個接口類型 E 的方法集合，包含兩個方法，分別是 M1 和 M2，它們組成了 E 這個接口類型所代表的接口。如果某個類型實現了方法 M1 和 M2，我們就說這個類型實現了 E 所代表的接口。
此時，我們再定義另外一個接口類型 I，它的方法集合中包含了三個方法 M1、M2 和 M3，如下面代碼：
type I interface {
M1()
M2()
M3()
}
我們看到接口類型 I 方法集合中的 M1 和 M2，與接口類型 E 的方法集合中的方法完全相同。在這種情況下，我們可以用接口類型 E 替代上面接口類型 I 定義中 M1 和 M2，如下面代碼：
type I interface {
E
M3()
}
像這種在一個接口類型（I）定義中，嵌入另外一個接口類型（E）的方式，就是我們說的接口類型的類型嵌入。
而且，這個帶有類型嵌入的接口類型 I 的定義與上面那個包含 M1、M2 和 M3 的接口類型 I 的定義，是等價的。因此，我們可以得到一個結論，這種接口類型嵌入的語義就是新接口類型（如接口類型 I）將嵌入的接口類型（如接口類型 E）的方法集合，并入到自己的方法集合中。
其實，使用類型嵌入方式定義接口類型也是 Go 組合設計哲學的一種體現。
按 Go 語言慣例，Go 中的接口類型中只包含少量方法，并且常常只是一個方法。通過在接口類型中嵌入其他接口類型可以實現接口的組合，這也是 Go 語言中基于已有接口類型構建新接口類型的慣用法。
按 Go 語言慣例，Go 中的接口類型中只包含少量方法，并且常常只是一個方法。通過在接口類型中嵌入其他接口類型可以實現接口的組合，這也是 Go 語言中基于已有接口類型構建新接口類型的慣用法。
我們在 Go 標準庫中可以看到很多這種組合方式的應用，最常見的莫過于 io 包中一系列接口的定義了。比如，io 包的 ReadWriter、ReadWriteCloser 等接口類型就是通過嵌入 Reader、Writer 或 Closer 三個基本的接口類型組合而成的。下面是僅包含單一方法的 io 包 Reader、Writer 和 Closer 的定義：
// $GOROOT/src/io/io.go
type Reader interface {
Read(p []byte) (n int, err error)
}
type Writer interface {
Write(p []byte) (n int, err error)
}
type Closer interface {
Close() error
}
下面的 io 包的 ReadWriter、ReadWriteCloser 等接口類型，通過嵌入上面基本接口類型組合而形成：
type ReadWriter interface {
Reader
Writer
}
type ReadCloser interface {
Reader
Closer
}
type WriteCloser interface {
Writer
Closer
}
type ReadWriteCloser interface {
Reader
Writer
Closer
}
不過，這種通過嵌入其他接口類型來創建新接口類型的方式，在 Go 1.14 版本之前是有約束的：如果新接口類型嵌入了多個接口類型，這些嵌入的接口類型的方法集合不能有交集，同時嵌入的接口類型的方法集合中的方法名字，也不能與新接口中的其他方法同名。比如我們用 Go 1.12.7 版本運行下面例子，Go 編譯器就會報錯：
type Interface1 interface {
M1()
}
type Interface2 interface {
M1()
M2()
}
type Interface3 interface {
Interface1
Interface2 // Error: duplicate method M1
}
type Interface4 interface {
Interface2
M2() // Error: duplicate method M2
}
func main() {
}
我們具體看一下例子中的兩個編譯報錯：第一個是因為 Interface3 中嵌入的兩個接口類型 Interface1 和 Interface2 的方法集合有交集，交集是方法 M1；第二個報錯是因為 Interface4 類型中的方法 M2 與嵌入的接口類型 Interface2 的方法 M2 重名。
但自 Go 1.14 版本開始，Go 語言去除了這些約束，我們使用 Go 最新版本運行上面這個示例就不會得到編譯錯誤了。
接口類型的類型嵌入比較簡單，我們只要把握好它的語義，也就是“方法集合并入”就可以了。
五、結構體類型的類型嵌入
5.1 結構體類型的類型嵌入介紹
結構體類型的類型嵌入是一種特殊的結構體定義方式，其中結構體的字段名可以直接使用類型名、類型的指針類型名或接口類型名，代表字段的名字和類型。以下是結構體類型的類型嵌入的關鍵點：
- 字段名和類型合二為一：在結構體類型的類型嵌入中，字段名和類型名合并成一個標識符，既代表了字段的名字又代表了字段的類型。這使得字段名與類型名保持一致，簡化了結構體定義。
- 嵌入字段：這種方式被稱為嵌入字段（Embedded Field），其中嵌入字段的類型可以是自定義類型、結構體類型的指針類型，或接口類型。
- 訪問嵌入字段：可以通過結構體變量來訪問嵌入字段的字段和方法，無需使用字段名，因為字段名已經隱含在類型中。
- 字段名與類型名一致：嵌入字段的字段名與類型名一致，這種一致性使得代碼更加清晰和直觀。
- 類型組合：通過嵌入字段，可以將不同類型的功能組合在一個結構體中，形成更復雜的數據結構，提高代碼的可維護性和擴展性。
5.2 小案例
通常，結構體都是類似下面這樣的：
type S struct {
A int
b string
c T
p *P
_ [10]int8
F func()
}
結構體類型 S 中的每個字段（field）都有唯一的名字與對應的類型，即便是使用空標識符占位的字段，它的類型也是明確的，但這還不是 Go 結構體類型的“完全體”。Go 結構體類型定義還有另外一種形式，那就是帶有嵌入字段（Embedded Field）的結構體定義。我們看下面這個例子：
type T1 int
type t2 struct{
n int
m int
}
type I interface {
M1()
}
type S1 struct {
T1
*t2
I
a int
b string
}
我們看到，結構體 S1 定義中有三個“非常規形式”的標識符，分別是 T1、t2 和 I，這三個標識符究竟代表的是什么呢？是字段名還是字段的類型呢？這里我直接告訴你答案：它們既代表字段的名字，也代表字段的類型。我們分別以這三個標識符為例，說明一下它們的具體含義：
- 標識符 T1 表示字段名為 T1，它的類型為自定義類型 T1；
- 標識符 t2 表示字段名為 t2，它的類型為自定義結構體類型 t2 的指針類型；
- 標識符 I 表示字段名為 I，它的類型為接口類型 I。
這種以某個類型名、類型的指針類型名或接口類型名，直接作為結構體字段的方式就叫做結構體的類型嵌入，這些字段也被叫做嵌入字段（Embedded Field）。
那么，嵌入字段怎么用呢？它跟普通結構體字段有啥不同呢？我們結合具體的例子，簡單說一下嵌入字段的用法：
type MyInt int
func (n *MyInt) Add(m int) {
*n = *n + MyInt(m)
}
type t struct {
a int
b int
}
type S struct {
*MyInt
t
io.Reader
s string
n int
}
func main() {
m := MyInt(17)
r := strings.NewReader("hello, go")
s := S{
MyInt: &m,
t: t{
a: 1,
b: 2,
},
Reader: r,
s: "demo",
}
var sl = make([]byte, len("hello, go"))
s.Reader.Read(sl)
fmt.Println(string(sl)) // hello, go
s.MyInt.Add(5)
fmt.Println(*(s.MyInt)) // 22
}
在分析這段代碼之前，我們要先明確一點，那就是嵌入字段的可見性與嵌入字段的類型的可見性是一致的。如果嵌入類型的名字是首字母大寫的，那么也就說明這個嵌入字段是可導出的。
現在我們來看這個例子。
首先，這個例子中的結構體類型 S 使用了類型嵌入方式進行定義，它有三個嵌入字段 MyInt、t 和 Reader。這里，你可能會問，為什么第三個嵌入字段的名字為 Reader 而不是 io.Reader？這是因為，Go 語言規定如果結構體使用從其他包導入的類型作為嵌入字段，比如 pkg.T，那么這個嵌入字段的字段名就是 T，代表的類型為 pkg.T。
接下來，我們再來看結構體類型 S 的變量的初始化。我們使用 field:value 方式對 S 類型的變量 s 的各個字段進行初始化。和普通的字段一樣，初始化嵌入字段時，我們可以直接用嵌入字段名作為 field。
而且，通過變量 s 使用這些嵌入字段時，我們也可以像普通字段那樣直接用 變量s + 字段選擇符 + 嵌入字段的名字，比如 s.Reader。我們還可以通過這種方式調用嵌入字段的方法，比如 s.Reader.Read 和 s.MyInt.Add。
這樣看起來，嵌入字段的用法和普通字段沒啥不同呀？也不完全是，Go 還是對嵌入字段有一些約束的。比如，和 Go 方法的 receiver 的基類型一樣，嵌入字段類型的底層類型不能為指針類型。而且，嵌入字段的名字在結構體定義也必須是唯一的，這也意味這如果兩個類型的名字相同，它們無法同時作為嵌入字段放到同一個結構體定義中。不過，這些約束你了解一下就可以了，一旦違反，Go 編譯器會提示你的。
六、“實現繼承”的原理
將上面例子代碼做一下細微改動，我這里只列了變化部分的代碼：
var sl = make([]byte, len("hello, go"))
s.Read(sl)
fmt.Println(string(sl))
s.Add(5)
fmt.Println(*(s.MyInt))
這段代碼中，類型 S 也沒有定義 Read 方法和 Add 方法，但是這段程序不但沒有引發編譯器報錯，還可以正常運行并輸出與前面例子相同的結果！
這段代碼似乎在告訴我們：Read 方法與 Add 方法就是類型 S 方法集合中的方法。但是，這里類型 S 明明沒有顯式實現這兩個方法呀，它是從哪里得到這兩個方法的實現的呢？
其實，這兩個方法就來自結構體類型 S 的兩個嵌入字段 Reader 和 MyInt。結構體類型 S “繼承”了 Reader 字段的方法 Read 的實現，也“繼承”了 *MyInt 的 Add 方法的實現。注意，我這里的“繼承”用了引號，說明這并不是真正的繼承，它只是 Go 語言的一種“障眼法”。
這種“障眼法”的工作機制是這樣的，當我們通過結構體類型 S 的變量 s 調用 Read 方法時，Go 發現結構體類型 S 自身并沒有定義 Read 方法，于是 Go 會查看 S 的嵌入字段對應的類型是否定義了 Read 方法。這個時候，Reader 字段就被找了出來，之后 s.Read 的調用就被轉換為 s.Reader.Read 調用。
這樣一來，嵌入字段 Reader 的 Read 方法就被提升為 S 的方法，放入了類型 S 的方法集合。同理 *MyInt 的 Add 方法也被提升為 S 的方法而放入 S 的方法集合。從外部來看，這種嵌入字段的方法的提升就給了我們一種結構體類型 S“繼承”了 io.Reader 類型 Read 方法的實現，以及 *MyInt 類型 Add 方法的實現的錯覺。
到這里，我們就清楚了，嵌入字段的使用的確可以幫我們在 Go 中實現方法的“繼承”。
在文章開頭，類型嵌入這種看似“繼承”的機制，實際上是一種組合的思想。更具體點，它是一種組合中的代理（delegate）模式，如下圖所示：
我們看到，S 只是一個代理（delegate），對外它提供了它可以代理的所有方法，如例子中的 Read 和 Add 方法。當外界發起對 S 的 Read 方法的調用后，S 將該調用委派給它內部的 Reader 實例來實際執行 Read 方法。
七、類型嵌入與方法集合
在前面，接口類型的類型嵌入時我們提到接口類型的類型嵌入的本質，就是嵌入類型的方法集合并入到新接口類型的方法集合中，并且，接口類型只能嵌入接口類型。而結構體類型對嵌入類型的要求就比較寬泛了，可以是任意自定義類型或接口類型。
下面我們就分別看看，在這兩種情況下，結構體類型的方法集合會有怎樣的變化。我們依舊借助上一講中的 dumpMethodSet 函數來輸出各個類型的方法集合，這里，我就不在例子中重復列出 dumpMethodSet 的代碼了。
7.1 結構體類型中嵌入接口類型
在結構體類型中嵌入接口類型后，結構體類型的方法集合會發生什么變化呢？我們通過下面這個例子來看一下：
type I interface {
M1()
M2()
}
type T struct {
I
}
func (T) M3() {}
func main() {
var t T
var p *T
dumpMethodSet(t)
dumpMethodSet(p)
}
運行這個示例，我們會得到以下結果：
main.T's method set:
- M1
- M2
- M3
*main.T's method set:
- M1
- M2
- M3
我們可以看到，原本結構體類型 T 只帶有一個方法 M3，但在嵌入接口類型 I 后，結構體類型 T 的方法集合中又并入了接口類型 I 的方法集合。并且，由于 *T 類型方法集合包括 T 類型的方法集合，因此無論是類型 T 還是類型 *T，它們的方法集合都包含 M1、M2 和 M3。于是我們可以得出一個結論：結構體類型的方法集合，包含嵌入的接口類型的方法集合。
不過有一種情況，你要注意一下，那就是當結構體嵌入的多個接口類型的方法集合存在交集時，你要小心編譯器可能會出現的錯誤提示。
雖然Go 1.14 版本解決了嵌入接口類型的方法集合有交集的情況，但那僅限于接口類型中嵌入接口類型，這里我們說的是在結構體類型中嵌入方法集合有交集的接口類型。
根據我們前面講的，嵌入了其他類型的結構體類型本身是一個代理，在調用其實例所代理的方法時，Go 會首先查看結構體自身是否實現了該方法。
如果實現了，Go 就會優先使用結構體自己實現的方法。如果沒有實現，那么 Go 就會查找結構體中的嵌入字段的方法集合中，是否包含了這個方法。如果多個嵌入字段的方法集合中都包含這個方法，那么我們就說方法集合存在交集。這個時候，Go 編譯器就會因無法確定究竟使用哪個方法而報錯，下面的這個例子就演示了這種情況：
type E1 interface {
M1()
M2()
M3()
}
type E2 interface {
M1()
M2()
M4()
}
type T struct {
E1
E2
}
func main() {
t := T{}
t.M1()
t.M2()
}
運行這個例子，我們會得到：
main.go:22:3: ambiguous selector t.M1
main.go:23:3: ambiguous selector t.M2
我們看到，Go 編譯器給出了錯誤提示，表示在調用 t.M1 和 t.M2 時，編譯器都出現了分歧。在這個例子中，結構體類型 T 嵌入的兩個接口類型 E1 和 E2 的方法集合存在交集，都包含 M1 和 M2，而結構體類型 T 自身呢，又沒有實現 M1 和 M2，所以編譯器會因無法做出選擇而報錯。
那怎么解決這個問題呢？其實有兩種解決方案。一是，我們可以消除 E1 和 E2 方法集合存在交集的情況。二是為 T 增加 M1 和 M2 方法的實現，這樣的話，編譯器便會直接選擇 T 自己實現的 M1 和 M2，不會陷入兩難境地。比如，下面的例子演示的就是 T 增加了 M1 和 M2 方法實現的情況：
... ...
type T struct {
E1
E2
}
func (T) M1() { println("T's M1") }
func (T) M2() { println("T's M2") }
func main() {
t := T{}
t.M1() // T's M1
t.M2() // T's M2
}
結構體類型嵌入接口類型在日常編碼中有一個妙用，就是可以簡化單元測試的編寫。由于嵌入某接口類型的結構體類型的方法集合包含了這個接口類型的方法集合，這就意味著，這個結構體類型也是它嵌入的接口類型的一個實現。即便結構體類型自身并沒有實現這個接口類型的任意一個方法，也沒有關系。我們來看一個直觀的例子：
package employee
type Result struct {
Count int
}
func (r Result) Int() int { return r.Count }
type Rows []struct{}
type Stmt interface {
Close() error
NumInput() int
Exec(stmt string, args ...string) (Result, error)
Query(args []string) (Rows, error)
}
// 返回男性員工總數
func MaleCount(s Stmt) (int, error) {
result, err := s.Exec("select count(*) from employee_tab where gender=?", "1")
if err != nil {
return 0, err
}
return result.Int(), nil
}
在這個例子中，我們有一個 employee 包，這個包中的方法 MaleCount，通過傳入的 Stmt 接口的實現從數據庫獲取男性員工的數量。
現在我們的任務是要對 MaleCount 方法編寫單元測試代碼。對于這種依賴外部數據庫操作的方法，我們的慣例是使用“偽對象（fake object）”來冒充真實的 Stmt 接口實現。
不過現在有一個問題，那就是 Stmt 接口類型的方法集合中有四個方法，而 MaleCount 函數只使用了 Stmt 接口的一個方法 Exec。如果我們針對每個測試用例所用的偽對象都實現這四個方法，那么這個工作量有些大。
那么這個時候，我們怎樣快速建立偽對象呢？結構體類型嵌入接口類型便可以幫助我們，下面是我們的解決方案：
package employee
import "testing"
type fakeStmtForMaleCount struct {
Stmt
}
func (fakeStmtForMaleCount) Exec(stmt string, args ...string) (Result, error) {
return Result{Count: 5}, nil
}
func TestEmployeeMaleCount(t *testing.T) {
f := fakeStmtForMaleCount{}
c, _ := MaleCount(f)
if c != 5 {
t.Errorf("want: %d, actual: %d", 5, c)
return
}
}
我們為 TestEmployeeMaleCount 測試用例建立了一個 fakeStmtForMaleCount 的偽對象類型，然后在這個類型中嵌入了 Stmt 接口類型。這樣 fakeStmtForMaleCount 就實現了 Stmt 接口，我們也實現了快速建立偽對象的目的。接下來我們只需要為 fakeStmtForMaleCount 實現 MaleCount 所需的 Exec 方法，就可以滿足這個測試的要求了。
7.2 結構體類型中嵌入結構體類型
在前面結構體類型中嵌入結構體類型，為 Gopher 們提供了一種“實現繼承”的手段，外部的結構體類型 T 可以“繼承”嵌入的結構體類型的所有方法的實現。并且，無論是 T 類型的變量實例還是 *T 類型變量實例，都可以調用所有“繼承”的方法。但這種情況下，帶有嵌入類型的新類型究竟“繼承”了哪些方法，我們還要通過下面這個具體的示例來看一下。
type T1 struct{}
func (T1) T1M1() { println("T1's M1") }
func (*T1) PT1M2() { println("PT1's M2") }
type T2 struct{}
func (T2) T2M1() { println("T2's M1") }
func (*T2) PT2M2() { println("PT2's M2") }
type T struct {
T1
*T2
}
func main() {
t := T{
T1: T1{},
T2: &T2{},
}
dumpMethodSet(t)
dumpMethodSet(&t)
}
在這個例子中，結構體類型 T 有兩個嵌入字段，分別是 T1 和 *T2，根據上一講中我們對結構體的方法集合的講解，我們知道 T1 與 *T1、T2 與 *T2 的方法集合是不同的：
- T1 的方法集合包含：
T1M1； -
*T1的方法集合包含：T1M1、PT1M2； -
T2的方法集合包含：T2M1； -
*T2的方法集合包含：T2M1、PT2M2。
它們作為嵌入字段嵌入到 T 中后，對 T 和 *T 的方法集合的影響也是不同的。我們運行一下這個示例，看一下輸出結果：
main.T's method set:
- PT2M2
- T1M1
- T2M1
*main.T's method set:
- PT1M2
- PT2M2
- T1M1
- T2M1
通過輸出結果，我們看到了 T 和 *T 類型的方法集合果然有差別的：
- 類型
T的方法集合 =T1的方法集合 +*T2的方法集合 - 類型
*T的方法集合 =*T1的方法集合 +*T2的方法集合
這里，我們尤其要注意 *T 類型的方法集合，它包含的可不是 T1 類型的方法集合，而是 *T1 類型的方法集合。這和結構體指針類型的方法集合包含結構體類型方法集合，是一個道理。
到這里，基于類型嵌入“繼承”方法實現的原理，我們基本都清楚了。但不知道你會不會還有一點疑惑：只有通過類型嵌入才能實現方法“繼承”嗎？如果我使用類型聲明語法基于一個已有類型 T 定義一個新類型 NT，那么 NT 是不是可以直接繼承 T 的所有方法呢？
八、defined 類型與 alias 類型是否可以實現方法集合的“繼承”？
8.1 defined 類型與 alias 類型的方法集合
Go 語言中，凡通過類型聲明語法聲明的類型都被稱為 defined 類型，下面是一些 defined 類型的聲明的例子：
type I interface {
M1()
M2()
}
type T int
type NT T // 基于已存在的類型T創建新的defined類型NT
type NI I // 基于已存在的接口類型I創建新defined接口類型NI
新定義的 defined 類型與原 defined 類型是不同的類型，那么它們的方法集合上又會有什么關系呢？新類型是否“繼承”原 defined 類型的方法集合呢？
這個問題，我們也要分情況來看。
對于那些基于接口類型創建的 defined 的接口類型，它們的方法集合與原接口類型的方法集合是一致的。但對于基于非接口類型的 defined 類型創建的非接口類型，我們通過下面例子來看一下：
package main
type T struct{}
func (T) M1() {}
func (*T) M2() {}
type T1 T
func main() {
var t T
var pt *T
var t1 T1
var pt1 *T1
dumpMethodSet(t)
dumpMethodSet(t1)
dumpMethodSet(pt)
dumpMethodSet(pt1)
}
在這個例子中，我們基于一個 defined 的非接口類型 T 創建了新 defined 類型 T1，并且分別輸出 T1 和 *T1 的方法集合來確認它們是否“繼承”了 T 的方法集合。
運行這個示例程序，我們得到如下結果：
main.T's method set:
- M1
main.T1's method set is empty!
*main.T's method set:
- M1
- M2
*main.T1's method set is empty!
從輸出結果上看，新類型 T1 并沒有“繼承”原 defined 類型 T 的任何一個方法。從邏輯上來說，這也符合 T1 與 T 是兩個不同類型的語義。
基于自定義非接口類型的 defined 類型的方法集合為空的事實，也決定了即便原類型實現了某些接口，基于其創建的 defined 類型也沒有“繼承”這一隱式關聯。也就是說，新 defined 類型要想實現那些接口，仍然需要重新實現接口的所有方法。
那么，基于類型別名（type alias）定義的新類型有沒有“繼承”原類型的方法集合呢？我們還是來看一個例子：
type T struct{}
func (T) M1() {}
func (*T) M2() {}
type T1 = T
func main() {
var t T
var pt *T
var t1 T1
var pt1 *T1
dumpMethodSet(t)
dumpMethodSet(t1)
dumpMethodSet(pt)
dumpMethodSet(pt1)
}
這個例子改自之前那個例子，我只是將 T1 的定義方式由類型聲明改成了類型別名，我們看一下這個例子的輸出結果：
main.T's method set:
- M1
main.T's method set:
- M1
*main.T's method set:
- M1
- M2
*main.T's method set:
- M1
- M2
通過這個輸出結果，我們看到，我們的 dumpMethodSet 函數甚至都無法識別出“類型別名”，無論類型別名還是原類型，輸出的都是原類型的方法集合。
由此我們可以得到一個結論：無論原類型是接口類型還是非接口類型，類型別名都與原類型擁有完全相同的方法集合。
九、小結
類型嵌入分為兩種，一種是接口類型的類型嵌入，對于接口類型的類型嵌入我們只要把握好其語義“方法集合并入”就可以了。另外一種是結構體類型的類型嵌入。通過在結構體定義中的嵌入字段，我們可以實現對嵌入類型的方法集合的“繼承”。
但這種“繼承”并非經典面向對象范式中的那個繼承，Go 中的“繼承”實際是一種組合，更具體點是組合思想下代理（delegate）模式的運用，也就是新類型代理了其嵌入類型的所有方法。當外界調用新類型的方法時，Go 編譯器會首先查找新類型是否實現了這個方法，如果沒有，就會將調用委派給其內部實現了這個方法的嵌入類型的實例去執行，你一定要理解這個原理。
此外，你還要牢記類型嵌入對新類型的方法集合的影響，包括：
-
結構體類型的方法集合包含嵌入的接口類型的方法集合；
-
當結構體類型
T包含嵌入字段E時，*T的方法集合不僅包含類型E的方法集合，還要包含類型*E的方法集合。
最后，基于非接口類型的 defined 類型創建的新 defined 類型不會繼承原類型的方法集合，而通過類型別名定義的新類型則和原類型擁有相同的方法集合。
總結
以上是生活随笔為你收集整理的Go类型嵌入介绍和使用类型嵌入模拟实现“继承”的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： Python 用户输入和字符串格式化指南
- 下一篇： 一个基于.NET7的开源DNS服务 Dn