go语⾔数组及结构体继承和初始化⽰例解析
⽬录
分类
数组
数组定义
结构体
结构体继承
结构体初始化
成员的操作
同名字段
其它匿名字段
⾮结构体类型
结构体指针类型
结构体字段实现接⼝
分类
类型名称长度默认值说明
pointer指针nil
array数组0
slice切⽚nil引⽤类型
map字典nil引⽤类型
struct结构体
数组
如果要存储班级⾥所有学⽣的数学成绩，应该怎样存储呢？可能有同学说，通过定义变量来存储。但是，问题是班级有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.str) }
结构体指针类型
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)
}
以上就是go语⾔数组及结构体继承和初始化⽰例解析的详细内容，更多关于go语⾔数组及结构体继承和初始化的资料请关注其它相关⽂章！

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。