嵌入类型
在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语言不知道如何处理。所以在这里需要明确的使用内部类型对象来调用对应的方法。