建立网站的数据表,网站建设推广小王,重庆网站建设解决方案及流程,wordpress主题kratosGo类型嵌入介绍和使用类型嵌入模拟实现“继承” 文章目录 Go类型嵌入介绍和使用类型嵌入模拟实现“继承”一、独立的自定义类型二、继承三、类型嵌入3.1 什么是类型嵌入 四、接口类型的类型嵌入4.1 接口类型的类型嵌入介绍4.2 一个小案例 五、结构体类型的类型嵌入5.1 结构体类…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 {EM3()
}像这种在一个接口类型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.gotype 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 {ReaderWriter
}type ReadCloser interface {ReaderCloser
}type WriteCloser interface {WriterCloser
}type ReadWriteCloser interface {ReaderWriterCloser
}不过这种通过嵌入其他接口类型来创建新接口类型的方式在 Go 1.14 版本之前是有约束的如果新接口类型嵌入了多个接口类型这些嵌入的接口类型的方法集合不能有交集同时嵌入的接口类型的方法集合中的方法名字也不能与新接口中的其他方法同名。比如我们用 Go 1.12.7 版本运行下面例子Go 编译器就会报错
type Interface1 interface {M1()
}type Interface2 interface {M1()M2()
}type Interface3 interface {Interface1Interface2 // Error: duplicate method M1
}type Interface4 interface {Interface2M2() // 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 intb stringc Tp *P_ [10]int8F func()
}结构体类型 S 中的每个字段field都有唯一的名字与对应的类型即便是使用空标识符占位的字段它的类型也是明确的但这还不是 Go 结构体类型的“完全体”。Go 结构体类型定义还有另外一种形式那就是带有嵌入字段Embedded Field的结构体定义。我们看下面这个例子
type T1 int
type t2 struct{n intm int
}type I interface {M1()
}type S1 struct {T1*t2I a intb string
}我们看到结构体 S1 定义中有三个“非常规形式”的标识符分别是 T1、t2 和 I这三个标识符究竟代表的是什么呢是字段名还是字段的类型呢这里我直接告诉你答案它们既代表字段的名字也代表字段的类型。我们分别以这三个标识符为例说明一下它们的具体含义
标识符 T1 表示字段名为 T1它的类型为自定义类型 T1标识符 t2 表示字段名为 t2它的类型为自定义结构体类型 t2 的指针类型标识符 I 表示字段名为 I它的类型为接口类型 I。
这种以某个类型名、类型的指针类型名或接口类型名直接作为结构体字段的方式就叫做结构体的类型嵌入这些字段也被叫做嵌入字段Embedded Field。
那么嵌入字段怎么用呢它跟普通结构体字段有啥不同呢我们结合具体的例子简单说一下嵌入字段的用法
type MyInt intfunc (n *MyInt) Add(m int) {*n *n MyInt(m)
}type t struct {a intb int
}type S struct {*MyInttio.Readers stringn 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, gos.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 Tvar p *TdumpMethodSet(t)dumpMethodSet(p)
}运行这个示例我们会得到以下结果
main.Ts method set:
- M1
- M2
- M3*main.Ts 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 {E1E2}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 {E1E2
}func (T) M1() { println(Ts M1) }
func (T) M2() { println(Ts M2) }func main() {t : T{}t.M1() // Ts M1t.M2() // Ts M2
}结构体类型嵌入接口类型在日常编码中有一个妙用就是可以简化单元测试的编写。由于嵌入某接口类型的结构体类型的方法集合包含了这个接口类型的方法集合这就意味着这个结构体类型也是它嵌入的接口类型的一个实现。即便结构体类型自身并没有实现这个接口类型的任意一个方法也没有关系。我们来看一个直观的例子
package employeetype Result struct {Count int
}func (r Result) Int() int { return r.Count }type Rows []struct{}type Stmt interface {Close() errorNumInput() intExec(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 employeeimport testingtype 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(T1s M1) }
func (*T1) PT1M2() { println(PT1s M2) }type T2 struct{}func (T2) T2M1() { println(T2s M1) }
func (*T2) PT2M2() { println(PT2s 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、PT1M2T2 的方法集合包含T2M1*T2 的方法集合包含T2M1、PT2M2。
它们作为嵌入字段嵌入到 T 中后对 T 和 *T 的方法集合的影响也是不同的。我们运行一下这个示例看一下输出结果
main.Ts method set:
- PT2M2
- T1M1
- T2M1*main.Ts 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 maintype T struct{}func (T) M1() {}
func (*T) M2() {}type T1 Tfunc main() {var t Tvar pt *Tvar t1 T1var pt1 *T1dumpMethodSet(t)dumpMethodSet(t1)dumpMethodSet(pt)dumpMethodSet(pt1)
}在这个例子中我们基于一个 defined 的非接口类型 T 创建了新 defined 类型 T1并且分别输出 T1 和 *T1 的方法集合来确认它们是否“继承”了 T 的方法集合。
运行这个示例程序我们得到如下结果
main.Ts method set:
- M1main.T1s method set is empty!*main.Ts method set:
- M1
- M2*main.T1s 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 Tfunc main() {var t Tvar pt *Tvar t1 T1var pt1 *T1dumpMethodSet(t)dumpMethodSet(t1)dumpMethodSet(pt)dumpMethodSet(pt1)
}这个例子改自之前那个例子我只是将 T1 的定义方式由类型声明改成了类型别名我们看一下这个例子的输出结果
main.Ts method set:
- M1main.Ts method set:
- M1*main.Ts method set:
- M1
- M2*main.Ts method set:
- M1
- M2通过这个输出结果我们看到我们的 dumpMethodSet 函数甚至都无法识别出“类型别名”无论类型别名还是原类型输出的都是原类型的方法集合。
由此我们可以得到一个结论无论原类型是接口类型还是非接口类型类型别名都与原类型拥有完全相同的方法集合。
九、小结
类型嵌入分为两种一种是接口类型的类型嵌入对于接口类型的类型嵌入我们只要把握好其语义“方法集合并入”就可以了。另外一种是结构体类型的类型嵌入。通过在结构体定义中的嵌入字段我们可以实现对嵌入类型的方法集合的“继承”。
但这种“继承”并非经典面向对象范式中的那个继承Go 中的“继承”实际是一种组合更具体点是组合思想下代理delegate模式的运用也就是新类型代理了其嵌入类型的所有方法。当外界调用新类型的方法时Go 编译器会首先查找新类型是否实现了这个方法如果没有就会将调用委派给其内部实现了这个方法的嵌入类型的实例去执行你一定要理解这个原理。
此外你还要牢记类型嵌入对新类型的方法集合的影响包括 结构体类型的方法集合包含嵌入的接口类型的方法集合 当结构体类型 T 包含嵌入字段 E 时*T 的方法集合不仅包含类型 E 的方法集合还要包含类型 *E 的方法集合。
最后基于非接口类型的 defined 类型创建的新 defined 类型不会继承原类型的方法集合而通过类型别名定义的新类型则和原类型拥有相同的方法集合。
