这篇文章主要为大家介绍了go语言数组及结构体继承和初始化示例解析，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步早日升职加薪 

分类

数组

如果要存储班级里所有学生的数学成绩，应该怎样存储呢？可能有同学说，通过定义变量来存储。但是，问题是班级有80个学生，那么要定义80个变量吗？

像以上情况，最好是通过数组的方式来存储。

所谓的数组：是指一系列同一类型数据的集合。

数组定义

var a [10]int

数组定义也是通过var关键字，后面是数组的名字a，长度是10,类型是整型。表示：数组a能够存储10个整型数字。也就是说，数组a的长度是10。 

我们可以通过len( )函数测试数组的长度，如下所示：

var a [10]int
fmt.Println(len(a)) //10

当定义完成数组a后，就在内存中开辟了10个连续的存储空间，每个数据都存储在相应的空间内，数组中包含的每个数据被称为数组元素（element），一个数组包含的元素个数被称为数组的长度。 

注意：数组的长度只能是常量。以下定义是错误的：

var n int = 10
var a [n]int

结构体 

package main
import "fmt"
func main(){

    // 1.定义结构体
    type Student struct{
        id int
        name string
        age int
        addr string
}
    //2.结构体初始化1，值的顺序与结构体成员的顺序保持一致
    chary := Student{1,"chary",18,"上海"}
    fmt.Println(chary) //{1 chary 18 上海}
    //2.结构体初始化2，没有初始化的成员自动赋值0
    jeff := Student{name:"jeff"}  //{0 jeff 0 }
    fmt.Println(jeff)
    //3.成员使用
    chary.id = 100  //修改
    fmt.Println(chary.id )
    //4.结构体比较,两个结构体可以使用 == 或 != 运算符进行比较，但不支持 > 或 <。
    fmt.Println(jeff==chary) //false
    //5.同类型的两个结构体变量可以相互赋值。
    var user Student
    user = jeff
    fmt.Println(user) //{0 jeff 0 }
}

结构体继承 

一般情况下，定义结构体的时候是字段名与其类型一一对应，实际上Go支持只提供类型，而不写字段名的方式，也就是匿名字段，也称为嵌入字段。

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

//人
type Person struct {
    name string
    sex byte
    age int
}
//学生
type Student struct {
    Person    //匿名字段，那么默认Student就包含了Person的所有字段
    id int
    addr string
}

结构体初始化 

//人
type Person struct {
    name string
    sex byte
    age int
}
//学生
type Student struct {
    Person//匿名字段，那么默认Student就包含了Person的所有字段
    id int
    addr string
}
func main() {
    //顺序初始化
    s1 := Student{Person{"mike",'m',18},1,"sz"}
    //s1 = {Person:{name:mike sex:109 age:18}id:1 addr:sz}
    fmt.Printf("s1=%+v\n",s1)
    //s2 := Student{"mike",'m',18,1,"sz"}//err
    //部分成员初始化1
    s3 := Student{Person:Person{"lily",'f',19},id:2}
    //s3 = {Person:{name:lily sex:102 age:19}id:2 addr:}
    fmt.Printf("s3=%+v\n",s3)
    //部分成员初始化2
    s4 := Student{Person:Person{name:"tom"},id:3}
    //s4 = {Person:{name:tomsex:0age:0}id:3addr:}
    fmt.Printf("s4=%+v\n",s4)
}

成员的操作 

var s1 Student//变量声明
//给成员赋值
s1.name = "mike"//等价于s1.Person.name="mike"
s1.sex = 'm'
s1.age = 18
s1.id = 1
s1.addr = "sz"
fmt.Println(s1)    //{{mike 109 18}1 sz}
var s2 Student//变量声明
s2.Person = Person{"lily",'f',19}
s2.id = 2
s2.addr = "bj"
fmt.Println(s2)    //{{lily 102 19}2 bj}

同名字段 

//人
type Person struct{
    name string
    sex byte
    age int
}
//学生
type Student struct{
    Person    //匿名字段，那么默认Student就包含了Person的所有字段
    id int
    addr string
    name string    //和Person中的name同名
}
func main(){
    var s Student//变量声明
    //给Student的name，还是给Person赋值？
    s.name = "mike"
    //{Person:{name:sex:0age:0}id:0addr:name:mike}
    fmt.Printf("%+v\n",s)
    //默认只会给最外层的成员赋值
    //给匿名同名成员赋值，需要显示调用
    s.Person.name = "yoyo"
    //Person:{name:yoyosex:0age:0}id:0addr:name:mike}
    fmt.Printf("%+v\n",s)
}

其它匿名字段 

非结构体类型

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

type mystr string//自定义类型
type Person struct {
    name string
    sex byte
    age int
}
type Student struct {
    Person    //匿名字段，结构体类型
    int    //匿名字段，内置类型
    mystr    //匿名字段，自定义类型
}
func main() {
    //初始化
    s1 := Student{Person{"mike",'m',18},1,"bj"}
    //{Person:{name:mikesex:109age:18}int:1mystr:bj}
    fmt.Printf("%+v\n",s1)
    //成员的操作，打印结果：mike,m,18,1,bj
    fmt.Printf("%s,%c,%d,%d,%s\n",s1.name,s1.sex,s1.age,s1.int,s1.mystr)
}

结构体指针类型 

type Person struct {    //人
    name string
    sex byte
    age int
}
type Student struct {//学生
    *Person    //匿名字段，结构体指针类型
    id int
    addr string
}
func main() {
    //初始化
    s1 := Student{&Person{"mike",'m',18},1,"bj"}
    //{Person:0xc0420023e0id:1addr:bj}
    fmt.Printf("%+v\n",s1)
    //mike,m,18
    fmt.Printf("%s,%c,%d\n",s1.name,s1.sex,s1.age)
    //声明变量
    var s2 Student
    s2.Person = new(Person)//分配空间
    s2.name = "yoyo"
    s2.sex = 'f'
    s2.age = 20
    s2.id = 2
    s2.addr = "sz"
    //yoyo10220220
    fmt.Println(s2.name,s2.sex,s2.age,s2.id,s2.age)
}

结构体字段实现接口 

package main
import (
    "fmt"
    "sync"
)
type UserAges struct {
    ages map[string] int
    sync.Mutex
}
func (u *UserAges)Add(name string,age int)  {
    u.Lock()
    defer u.Unlock()
    u.ages[name] = age
}
func (u *UserAges)Get(name string)int{
    if age,ok:=u.ages[name];ok{
        return age
    }
    return -1
}
func main() {
    dic:=make(map[string]int)
    dic["age"] = 18
    r:=UserAges{ages: dic}
    r.Add("jeff",20)
    fmt.Println(r)
    age:=r.Get("age")
    fmt.Println(age)
}