go 匿名字段

go 匿名字段

原文： 

定义一个struct，定义的时候是字段名与其类型一一对应，实际上Go语言支持只提供类型，而不写字段名的方式，也就是匿名字段，或称为嵌入字段。

当匿名字段是一个struct的时候，那么这个struct所拥有的全部字段都被隐式地引入了当前定义的这个struct。

type Human struct {

    name string

    age int

    weight int

    phone  string

}

不仅仅是struct字段，所有的内置类型和自定义类型都可以作为匿名字段

type Skills []string

type Student struct {

    Human  // 匿名字段，那么默认Student就包含了Human的所有字段

    Skills //匿名字段

    speciality string

    phone  string

}

type Skills []string

mark.Skills = []string{"anatomy"}

fmt.Println("His name is ", mark.name)

最外层的优先访问，也就是当你通过student.phone访问的时候，是访问student里面的字段，而不是human里面的字段。

fmt.Println("Student phone is ", mark.phone)

fmt.Println("Student phone is ", mark.Human.phone) 

Go语言中的结构体可以定义匿名字段。Go语言中没有对象，但是结构体却有大量对象的功能。并且用匿名字段的确可以实现对象的继承和重载

A1得到了A的所有字段，A称为匿名字段。A1同样也得到A的所有方法，这个可称为继承：

type A struct{}

func (self *A)do() {
    fmt.Println("A.do")  
}

type A1 struct {
    A
}
func main(){
    var a A1
    a.do()  
}

在A1中能定义和A中重名的方法，这个可称为重写： 重写方法和字段一样，遵循最外层的优先访问原则

type A struct{
}

func (self *A)do() {
    fmt.Println("A.do")  
}

type A1 struct {
    A
}

func (self *A1) do() {
    fmt.Println("A1.do")
}

func main(){
    var a A1
    a.do() 
    a.A.do()
}

go不是面向对象的语言，举例：

type parent struct{    

}


type child struct{
    parent
}

func(p *parent)MethodA(){
    fmt.Println("parent MethodA")
    p.MethodB()
}

func(p *parent)MethodB(){
    fmt.Println("parent MethodB")
}

func(c *child)MethodB(){
    fmt.Println("child MethodB")
}

func main() {
    child := new(child)
    child.MethodA()  
}

结果：

parent MethodA
 parent MethodB

解释：

go不是面向对象的语言，go的方法调用是依据"对象"类型的,而不是对象本身，go使用组合的方式实现"继承"，方法与结构类型绑定，而不是对象