结构、接口

go语言里没有类的概念，也不支持继承。但是，通过组合结构和方法，就可以实现面向对象设计的相关概念。

1.结构（struct）

熟悉java的同学可以把它理解为一个bean的结构体。
结构体里面包含多个定义的数据名称及类型。

func main() {
    var people struct{
        name string
        age int
    }
    people.name = "张三"
    people.age = 18

    fmt.Println(people)
}

当然如果有很多地方使用到这个结构体的话，也可以把结构体定义为type类型，这样就可以通过var之类的方式初始化很多该结构体。

func main() {
    type people struct{
        name string
        age int
    }
    var people1 = people{name: "张三",age: 18}
    var people2 = people{name: "李四",age: 19}

    fmt.Println(people1,people2)
}

结构的作用是将多个值打包组合成一个单元。
结构也可以构成切片类型，把结构当做一个普通的类型切片使用就可以了。

和普通类型type定义方法一样，也可以为结构定义方法。

func main() {
    var people1 = people{name: "张三",age: 18}
    var people2 = people{name: "李四",age: 19}

    fmt.Println(people1.getPeopleNameAge(),people2.getPeopleNameAge())
}

type people struct{
    name string
    age int
}

func (p people)getPeopleNameAge() string{
    return p.name + " " + strconv.Itoa(p.age)
}

2.结构的合并组合

对于有大量数据的结构来说，如果结构体里面充斥着大量数据，肯定不是啥好事，毕竟管理起来也挺费事的。
这个时候我们可以把结构体里面的内容再拆分成很多小的结构体，这样小的结构体可以单独使用，大的结构体数据也是完整的。

func main() {
    peopleSkill := peopleSkill{id: 0,people: people{name : "张三",age:18},skill: skill{skillName:"钢琴",time: 3}}

    fmt.Println(peopleSkill)
    //如果要调用子结构的方法，可以通过点的方式调用
    peopleSkill.people.getPeopleNameAge()
    //也可以给父结构体定义一个转发，然后调用
    peopleSkill.getPeopleNameAge()
}

type people struct{
    name string
    age int
}

type skill struct {
    skillName string
    time int32
}

type peopleSkill struct {
    id int
    people people
    skill skill
}

func (p people)getPeopleNameAge() string{
    return p.name + " " + strconv.Itoa(p.age)
}

//也可以给父结构体定义一个转发
func (p peopleSkill)getPeopleNameAge() string{
    return p.people.getPeopleNameAge()
}

当然，定义结构体时舍弃其它结构体的字段名，就可以实现自动转发。除了转发，还能自动调用子结构的字段。

//将peopleSkill这样定义，上面main中调用的方法可以正常使用
type peopleSkill struct {
    id int
    people
    skill
}

//在main中还可以这样调用其子结构的字段
func main() {
    peopleSkill := peopleSkill{id: 0,people: people{name : "张三",age:18},skill: skill{skillName:"钢琴",time: 3}}

    peopleSkill.skillName
    peopleSkill.age
}

3.接口

go语言里的接口没有继承概念，只要实现了接口里的方法就属于该接口类型，这样在一个函数接受该接口的时候，所有符合规则的类型和结构都是适用的。
对于实现了接口的类型或结构体，如果嵌入在了另一个结构体里面，那么该结构体也相当于实现了这个接口。

func main() {
    peopleSkill := peopleSkill{id: 0, people: people{name: "张三", age: 18}, skill: skill{skillName: "钢琴", time: 3}}

    music = peopleSkill.skill
    fmt.Println(music.startMusic())//使用 钢琴 演奏了歌曲

    music = peopleSkill.people
    fmt.Println(music.startMusic())//张三 唱起了歌

    music = peopleSkill
    fmt.Println(music.startMusic())//张三使用 钢琴 演奏了歌曲
}

var music interface {
    startMusic() string
}

type people struct {
    name string
    age  int
}

type skill struct {
    skillName string
    time      int32
}

type peopleSkill struct {
    id int
    people
    skill
}

func (p people) startMusic() string {
    return p.name + " 唱起了歌"
}

func (s skill) startMusic() string {
    return "使用 " + s.skillName + " 演奏了歌曲"
}

func (p peopleSkill) startMusic() string {
    return p.name + "使用 " + p.skillName + " 演奏了歌曲"
}

如果需要多个继承了接口的变量，可以将var换成type类型，这样就可以随意创建使用了。