go语言数组及结构体继承和初始化示例解析_Golang_脚本之家

目录

分类

类型

名称

长度

默认值

说明

pointer

指针

 

nil

 

array

数组

 

0

 

slice

切片

 

nil

引⽤类型

map

字典

 

nil

引⽤类型

struct

结构体

 

 

 

数组

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

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

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

数组定义

?

1

var a [`10]int`

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

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

?

1

2

var a [`10]int`

fmt.`Println(len`(a)) //10

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

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

?

1

2

var n int = 10

var a [n]`int`

结构体

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

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支持只提供类型，而不写字段名的方式，也就是匿名字段，也称为嵌入字段。

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

自媒体培训

?

1

2

3

4

5

6

7

8

9

10

11

12

//人

type Person struct {

name string

sex byte

age int

}

//学生

type Student struct {

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

id int

addr string

}

结构体初始化

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

//人

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=%+vn"`,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=%+vn"`,s3)

//部分成员初始化2

s4 := Student{Person:Person{name:`"tom"},id:3`}

//s4 = {Person:{name:tomsex:0age:0}id:3addr:}

fmt.Printf(`"s4=%+vn"`,s4)

}

成员的操作

?

1

2

3

4

5

6

7

8

9

10

11

12

13

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}

同名字段

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

//人

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(`"%+vn"`,s)

//默认只会给最外层的成员赋值

//给匿名同名成员赋值，需要显示调用

s.Person.name = "yoyo"

//Person:{name:yoyosex:0age:0}id:0addr:name:mike}

fmt.Printf(`"%+vn"`,s)

}

其它匿名字段

非结构体类型

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

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

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(`"%+vn"`,s1)

//成员的操作，打印结果：mike,m,18,1,bj

fmt.Printf(`"%s,%c,%d,%d,%sn",s1.name,s1.sex,s1.age,s1.int`,s1.mystr)

}

结构体指针类型

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

type Person struct { //人

name string

sex byte

age int

}

type Student struct {`//学生`

*Person //匿名字段，结构体指针类型

id int

addr string

}

func main() {

//初始化

s1 := Student{&amp;Person{`"mike",'m',18},1,"bj"`}

//{Person:0xc0420023e0id:1addr:bj}

fmt.Printf(`"%+vn"`,s1)

//mike,m,18

fmt.Printf(`"%s,%c,%dn"`,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)

}

结构体字段实现接口

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

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语言数组及结构体继承和初始化的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

原网址: 访问
创建于: 2022-09-06 18:50:53
目录: default
标签: 无

未标明原创文章均为采集，版权归作者所有，转载无需和我联系，请注明原出处，南摩阿彌陀佛，知识，不只知道，要得到

请先后发表评论
  • 最新评论
  • 总共0条评论