【Go学习笔记14】嵌入类型（继承）

嵌入类型

在go语言中，嵌入类型表示，在一个自定义类型中可以嵌入另一种类型。而被嵌入的类型自动拥有嵌入类型实现的接口方法以及属性。其实，这就是go语言中继承的实现机制。

（继承）属性

package main

import (
	"fmt"
)

type user struct{
	name string
	age int
}

type admin struct{
	user	//嵌入user类型
	level int
}

func main(){
	//初始化一个admin类型的对象
	ad := admin{
		user:user{
			name:"zhongzhong",
			age:25,
		},
		level:1,
	}
	//可以直接访问嵌入类型的属性
	fmt.Println(ad.name)
	fmt.Println("mian函数执行完成")
}
//zhongzhong
//mian函数执行完成

复制代码

上面的代码中定义了两个类型，user和admin。在admiin中嵌入了user类型。注意，嵌入类型只需要声明类型就可以了。 在上面的代码中，我们把admin称为外部类型，user称为内部类型。

（继承）方法

除了上面的内部类型的属性自动提升到外部类型之外，内部类型实现的接口，也会提升到外部类型。看下面的代码：

package main

import (
	"fmt"
)
type Speaker interface{
	speak(content string)
}

type user struct{
	name string
	age int
}
//使用user类型的值作为接收者实现Speaker接口
func (u user) speak(content string){
	fmt.Println(u.name,":",content)
}

type admin struct{
	user	//嵌入user类型
	level int
}

func main(){
	//初始化一个admin类型的对象
	ad := admin{
		user:user{
			name:"zhongzhong",
			age:25,
		},
		level:1,
	}
	//使用内部类型调用
	ad.user.speak("你好啊")
	//直接使用外部类型调用
	ad.speak("你好")
	fmt.Println("mian函数执行完成")
}
//zhongzhong : 你好啊
//zhongzhong : 你好
//mian函数执行完成

复制代码

上面的代码，既可以使用admin对象来调用speak方法也可以使用admin对象的嵌入类型的user对象来调用speak。这就表示，在外部类型中，可以直接使用内部类型的方法。

覆盖方法（重写）

从上面可以看出，外部类型可以直接使用内部类型的方法，那么如果我不想使用内部类型的方法怎么办呢？看下面的代码：

package main

import (
	"fmt"
)
type Speaker interface{
	speak(content string)
}

type user struct{
	name string
	age int
}

type admin struct{
	user	//嵌入user类型
	level int
}


//使用user类型的值作为接收者实现Speaker接口
func (u user) speak(content string){
	fmt.Println(u.name,":",content)
}

//使用admin类型的值作为接收者实现Speaker接口
func (a admin) speak(content string){
	fmt.Println(a.name,"-",a.level,":",content)
}

func main(){
	//初始化一个admin类型的对象
	ad := admin{
		user:user{
			name:"zhongzhong",
			age:25,
		},
		level:1,
	}
	//使用内部类型调用
	ad.user.speak("你好啊")
	//直接使用外部类型调用
	ad.speak("你好")
	fmt.Println("mian函数执行完成")
}
//zhongzhong : 你好啊
//zhongzhong - 1 : 你好
//mian函数执行完成
复制代码

从上面的输出结果可以看出，如果外部类型和内部类型实现了同样的接口，那么使用外部类型调用接口的方法的时候，就是调用外部类型实现的方法而不再是内部类型的方法。也就是说，外部类型的方法会覆盖内部类型的方法。这和java中的重写类似。

来看一个复杂点的例子：

package main

import (
	"fmt"
)
type Speaker interface{
	speak(content string)
}

type user struct{
	name string
	age int
}

type speakerA struct{
	propA int
}

type admin struct{
	user	//嵌入user类型
	speakerA //嵌入speakerA类型
	level int
}

//使用user类型的值作为接收者实现Speaker接口
func (u user) speak(content string){
	fmt.Println(u.name,":",content)
}

//使用speakerA类型的值作为接收者实现Speaker接口
func (s speakerA) speak(content string){
	fmt.Println(s.propA,":",content)
}



func main(){
	//初始化一个admin类型的对象
	ad := admin{
		user:user{
			name:"zhongzhong",
			age:25,
		},
		speakerA:speakerA{
			propA:100,
		},
		level:1,
	}
	//只能使用这种调用方式
	ad.user.speak("你好啊")
	//只能使用这种调用方式
	ad.speakerA.speak("你好")
	fmt.Println("mian函数执行完成")
}
//zhongzhong : 你好啊
//100 : 你好
//mian函数执行完成
复制代码

上面的代码，admin嵌入了user，speakerA两种类型，而且这两种类型都实现了Speaker接口。造成在使用外部类型对象调用的时候，go语言不知道如何处理。所以在这里需要明确的使用内部类型对象来调用对应的方法。

转载于:https://juejin.im/post/5a2b4e605188252ae93addf0