Golang learning 结构体 struct 与面向对

Go 语言并不是传统意义上的面向对象语言，但是实现很小的面向对象的机制。
匿名嵌入并不是继承，无法实现多态处理，虽然配合方法集，可用接口来实现一些类似操作，但是其本质是完全不同的。

type Animal struct {          声明Animal
    name string
    age  int
}
type Cat struct {

    Animal                       匿名字段
    teeth string  "牙"         "牙" 不是注释，字段标签(tag)不是注释，是用来描述字段的元数据，是struct的一部分
    leg  int
}

type Animal struct {                        声明Animal类
    name string
    age  int
}
type AnimalAction interface {        声明AnimalAction  接口类

    eat()                                        声明func
    voice()                                     声明func

}
func (a Animal) eat(){                  Animal实现接口AnimalAction    方法eat()

    fmt.Print("eat")
}
func (a Animal) voice(){                 Animal实现接口AnimalAction    方法voice()

    fmt.Print("voice")
}




type Cat struct {                         声明Cat类  
    Animal                                匿名字段Animal     嵌入类型
    teeth string "牙"
    leg  int
}

type NewAction interface {     声明NewAction  接口类
    run()
        sing(s func(name string))   声明闭包sing
}

func (c Cat) eat(){                    Cat实现 func eat(),类似继承的重写，但不是重写。 
    c.Animal.eat()                    Cat调用Animal func eat()，类似super.eat()  但不是调用父类方法
    fmt.Print("cat eat")

}
func (c Cat) run(){                    Cat实现NewAction func run()

    fmt.Print("cat run")

}
func (c Cat) sing(s func(name string)){       实现闭包sing
    s("cat")
}

func test(){


   a := Animal{
    "a",
    12,

   }
   a.eat()
   a.voice()

   c := Cat{
    Animal{
        "cat",
        1,
    },
    "尖牙",
    4,
   }

   c.eat()
   c.voice()
   c.run()

   c.sing(func(name string) {         调用闭包

      fmt.Print("\n" + name + "sing")
   })


}