• Go基础4

    目录

    一. 结构体

    1.1 结构体的定义

    1.1.1 匿名结构体

    1.2 结构体指针

    1.3 结构体初始化

    1.4 结构体内存布局

    1.5 构造函数

    1.6 方法和接收者

    1.7 值和指针接收者

    1.8 任意类型添加方法

    1.9 结构体的匿名字段

    1.10 结构体嵌套

    1.11 匿名嵌套结构体

    1.12 嵌套结构体的字段名冲突

    1.13 结构体模拟实现继承

    1.14 练习

    1.14.1 学生管理系统（函数版）

    1.15 结构体与JSON序列化

    二. 接口

    2.1 接口的类型

    2.2 值接收者和指针接收者

    2.2.1 值接收者

    2.2.2 指针接收者

    2.3 类型与接口的关系

    2.4 空接口

    2.5 类型断言

     

    一. 结构体

    Go语言中的基础数据类型可以表示一些事物的基本属性，但是当我们想表达一个事物的全部或部分属性时，这时候再用单一的基本数据类型明显就无法满足需求了，Go语言提供了一种自定义数据类型，可以封装多个基本数据类型，这种数据类型叫结构体，英文名称struct。 也就是我们可以通过struct来定义自己的类型了。

    Go语言中通过struct来实现面向对象。

    1.1 结构体的定义

    使用type和struct关键字来定义结构体，具体代码格式如下：

    1. type 类型名 struct {
    2.     字段名 字段类型
    3.     字段名 字段类型
    4.     …
    5. }

    • 类型名：标识自定义结构体的名称，在同一个包内不能重复。

    • 字段名：表示结构体字段名。结构体中的字段名必须唯一。

    • 字段类型：表示结构体字段的具体类型。

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. // 自定义结构体
    6. type person struct {
    7. 	name  string
    8. 	age   int
    9. 	sex   string
    10. 	hobby []string
    11. 	other string
    12. }
    13.  
    14. func main() {
    15. 	var p person
    16. 	p.name = "老王"
    17. 	p.age = 35
    18. 	p.sex = "男"
    19. 	p.hobby = []string{"篮球", "足球", "双色球"}
    20. 	p.other = "暂无"
    21.  
    22. 	fmt.Println(p)
    23. 	fmt.Println(p.age) // 输出相应的属性
    24. 	fmt.Println(p.hobby)
    25. }
    26.  
    27. {老王 35 男 [篮球 足球 双色球] 暂无}
    28. 35
    29. [篮球 足球 双色球]

    1.1.1 匿名结构体

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"reflect"
    6. )
    7.  
    8. func main() {
    9. 	// 匿名结构体
    10. 	var s struct {
    11. 		name string
    12. 		age  int
    13. 	}
    14. 	s.age = 45
    15. 	s.name = "很漂亮"
    16.  
    17. 	fmt.Println(reflect.TypeOf(s), s)
    18.  
    19. }
    20.  
    21. struct { name string; age int } {很漂亮 45}

    1.2 结构体指针

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. // 定义一个结构体
    6. type person struct {
    7. 	name, sex string
    8. 	age       int
    9. }
    10.  
    11. // go语言中函数的参数永远是拷贝
    12. func f1(x person) {
    13. 	x.age = 18 // 也就是说这里修改的是副本的age
    14. }
    15.  
    16. /* 假如要想在函数中修改变量，就要使用指针 */
    17. func f2(x *person) {
    18. 	// (*x).age = 18  // 根据内存地址找原来的变量，进行修改
    19. 	x.age = 18 // 同上，语法糖，自动根据指针找到对应的变量
    20. }
    21.  
    22. func main() {
    23. 	var p person // 声明一个person类型的变量p
    24. 	p.age = 22
    25. 	p.name = "老王"
    26. 	p.sex = "男"
    27. 	f1(p)
    28. 	fmt.Println(p)
    29.  
    30. 	f2(&p) // 传入内存地址
    31. 	fmt.Println(p)
    32. }
    33.  
    34. {老王 男 22}
    35. {老王 男 18}

    1.3 结构体初始化

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. )
    6.  
    7. type person struct {
    8. 	name string
    9. 	age  int
    10. }
    11.  
    12. func main() {
    13. 	p1 := person{ // 初始化及赋值
    14. 		name: "很漂亮",
    15. 		age:  20,
    16. 	}
    17. 	fmt.Println(p1)
    18.  
    19. 	p2 := person{ // 只使用值进行初始化及赋值（要按照顺序进行赋值）
    20. 		"老王",
    21. 		35,
    22. 	}
    23. 	fmt.Println(p2)
    24.  
    25. 	p3 := &person{ // 指针类型的结构体
    26. 		"胖子",
    27. 		24,
    28. 	}
    29. 	fmt.Println(p3)
    30. }
    31.  
    32. {很漂亮 20}
    33. {老王 35}
    34. &{胖子 24}

    1.4 结构体内存布局

    结构体占用一块连续的内存。

    1. type test struct {
    2. 	a int8
    3. 	b int8
    4. 	c int8
    5. 	d int8
    6. }
    7. n := test{
    8. 	1, 2, 3, 4,
    9. }
    10. fmt.Printf("n.a %p\n", &n.a)
    11. fmt.Printf("n.b %p\n", &n.b)
    12. fmt.Printf("n.c %p\n", &n.c)
    13. fmt.Printf("n.d %p\n", &n.d)
    14.  
    15. n.a 0xc0000a0060
    16. n.b 0xc0000a0061
    17. n.c 0xc0000a0062
    18. n.d 0xc0000a0063

    1.5 构造函数

    Go语言的结构体没有构造函数，我们可以自己实现。因为struct是值类型，如果结构体比较复杂的话，值拷贝性能开销会比较大，所以该构造函数返回的是结构体指针类型。

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type s struct {
    6. 	name string
    7. 	age  int
    8. 	sex  string
    9. }
    10.  
    11. // 在Go语言中，构造函数都是以new开始的
    12. // 当结构体比较大时，尽量使用结构体指针，减少程序的开销
    13. func newPerson(name, sex string, age int) *s {
    14. 	return &s{
    15. 		name: name,
    16. 		age:  age,
    17. 		sex:  sex,
    18. 	}
    19. }
    20.  
    21. func main() {
    22. 	s1 := newPerson("hpl", "男", 23)
    23. 	s2 := newPerson("老王", "男", 34)
    24. 	fmt.Println(s1, s2)
    25. }
    26.  
    27. &{hpl 23 男} &{老王 34 男}

    1.6 方法和接收者

    Go语言中的方法（Method）是一种作用于特定类型变量的函数。这种特定类型变量叫做接收者（Receiver）。接收者的概念就类似于其他语言中的this或者 self。

    方法的定义格式如下：

    1. func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
    2.     函数体
    3. }

    • 接收者变量：接收者中的参数变量名在命名时，官方建议使用接收者类型名称首字母的小写，而不是self、this之类的命名。例如，Person类型的接收者变量应该命名为 p，Connector类型的接收者变量应该命名为c等。

    • 接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型。

    • 方法名、参数列表、返回参数：具体格式与函数定义相同。

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type dog struct {
    6. 	name string
    7. }
    8.  
    9. // 方法
    10. func (d dog) d1() {
    11. 	fmt.Printf("%s:汪汪汪~", d.name)
    12. }
    13.  
    14. func main() {
    15. 	dd := dog{
    16. 		"老王",
    17. 	}
    18. 	dd.d1()
    19. }
    20.  
    21. 老王:汪汪汪~

    方法与函数的区别是：函数不属于任何类型，方法属于特定的类型。

    1.7 值和指针接收者

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type dog struct {
    6. 	name string
    7. 	age  int
    8. }
    9.  
    10. // 使用值接收者（传值拷贝进去）
    11. func (d dog) f1() {
    12. 	d.age++
    13. }
    14.  
    15. // 使用指针接收者（传指针进去）
    16. func (d *dog) f2() {
    17.     // (*d).age++
    18. 	d.age++
    19. }
    20.  
    21. func main() {
    22. 	d1 := dog{"老王", 12}
    23. 	d1.f1()
    24. 	fmt.Println(d1)
    25.  
    26. 	d1.f2()
    27. 	fmt.Println(d1)
    28.  
    29. }
    30.  
    31. {老王 12}
    32. {老王 13}

    什么时候应该使用指针类型接收者：

    1. 需要修改接收者中的值

    2. 接收者是拷贝代价比较大的大对象

    3. 保证一致性，如果有某个方法使用了指针接收者，那么其他的方法也应该使用指针接收者。

    1.8 任意类型添加方法

    在Go语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。 如：基于内置的int类型使用type关键字可以定义新的自定义类型，然后为我们的自定义类型添加方法。

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"reflect"
    6. )
    7.  
    8. type myInt int // 自定义一个类型
    9.  
    10. func (m myInt) hello() {
    11. 	fmt.Println("我是一个myInt类型")
    12. }
    13.  
    14. func main() {
    15. 	m := myInt(100)
    16. 	m1 := 200
    17. 	fmt.Println(reflect.TypeOf(m))
    18. 	fmt.Println(reflect.TypeOf(m1))
    19. 	m.hello()
    20.  
    21. }
    22.  
    23. main.myInt
    24. int
    25. 我是一个myInt类型

    注意事项： 非本地类型不能定义方法，也就是说我们不能给别的包的类型定义方法。

    1.9 结构体的匿名字段

    结构体允许其成员字段在声明时没有字段名而只有类型，这种没有名字的字段就称为匿名字段。

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. // 匿名字段
    6. type person struct {
    7. 	string
    8. 	int
    9. }
    10.  
    11. func main() {
    12. 	p1 := person{
    13. 		"老王",
    14. 		34,
    15. 	}
    16. 	fmt.Println(p1)
    17. 	fmt.Println(p1.string)
    18. 	fmt.Println(p1.int)
    19. }
    20.  
    21. {老王 34}
    22. 老王
    23. 34

    适用于字段比较少且简单的场景（不常用）

    注意：这里匿名字段的说法并不代表没有字段名，而是默认会采用类型名作为字段名，结构体要求字段名称必须唯一，因此一个结构体中同种类型的匿名字段只能有一个。

    1.10 结构体嵌套

    一个结构体中可以嵌套包含另一个结构体或结构体指针。

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. // 结构体的嵌套
    6. type introduce struct {
    7. 	name    string
    8. 	city    string
    9. 	address string
    10. }
    11.  
    12. type person struct {
    13. 	age  int
    14. 	addr introduce
    15. }
    16.  
    17. type company struct {
    18. 	addr introduce
    19. }
    20.  
    21. func main() {
    22. 	p1 := person{
    23. 		age: 23,
    24. 		addr: introduce{
    25. 			name:    "老王",
    26. 			city:    "汉中",
    27. 			address: "陕西省汉中市洋县",
    28. 		},
    29. 	}
    30. 	fmt.Println(p1)
    31. 	fmt.Println(p1.age)
    32. 	fmt.Println(p1.addr)
    33. 	fmt.Println(p1.addr.name)
    34. }
    35.  
    36. {23 {老王 汉中 陕西省汉中市洋县}}
    37. 23
    38. {老王 汉中 陕西省汉中市洋县}
    39. 老王

    1.11 匿名嵌套结构体

    结构体中嵌套的person结构体也可以采用匿名字段的方式

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type address struct {
    6. 	name string
    7. 	city string
    8. }
    9.  
    10. type person struct {
    11. 	age     int
    12. 	address // 匿名嵌套体
    13. }
    14.  
    15. type company struct {
    16. 	addr address
    17. }
    18.  
    19. func main() {
    20. 	p1 := person{
    21. 		age: 23,
    22. 		address: address{
    23. 			name: "hpl",
    24. 			city: "汉中",
    25. 		},
    26. 	}
    27. 	fmt.Println(p1)
    28. 	fmt.Println(p1.address)
    29. 	fmt.Println(p1.age)
    30. 	fmt.Println(p1.name)
    31. }
    32.  
    33. {23 {hpl 汉中}}
    34. {hpl 汉中}
    35. 23
    36. hpl

    当访问结构体成员时会先在结构体中查找该字段，找不到再去嵌套的匿名字段中查找。

    1.12 嵌套结构体的字段名冲突

    嵌套结构体内部可能存在相同的字段名。在这种情况下为了避免歧义需要通过指定具体的内嵌结构体字段名。

    1. //Address 地址结构体
    2. type Address struct {
    3. 	Province   string
    4. 	City       string
    5. 	CreateTime string
    6. }
    7.  
    8. //Email 邮箱结构体
    9. type Email struct {
    10. 	Account    string
    11. 	CreateTime string
    12. }
    13.  
    14. //User 用户结构体
    15. type User struct {
    16. 	Name   string
    17. 	Gender string
    18. 	Address
    19. 	Email
    20. }
    21.  
    22. func main() {
    23. 	var user3 User
    24. 	user3.Name = "沙河娜扎"
    25. 	user3.Gender = "男"
    26. 	// user3.CreateTime = "2019" //ambiguous selector user3.CreateTime
    27. 	user3.Address.CreateTime = "2000" //指定Address结构体中的CreateTime
    28. 	user3.Email.CreateTime = "2000"   //指定Email结构体中的CreateTime
    29. }

    1.13 结构体模拟实现继承

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type animal struct {
    6. 	name string
    7. }
    8.  
    9. // 给animal实现一个eat的方法
    10. func (a animal) eat() {
    11. 	fmt.Printf("名字叫%s的狗狗在吃饭\n", a.name)
    12. }
    13.  
    14. type dog struct {
    15. 	age int
    16. 	animal
    17. }
    18.  
    19. // 给狗实现一个叫的方法
    20. func (d dog) call() {
    21. 	fmt.Printf("名字叫%s的狗狗今年%d岁\n", d.name, d.age)
    22. }
    23.  
    24. func main() {
    25. 	a1 := animal{
    26. 		name: "老王",
    27. 	}
    28. 	a1.eat()
    29.  
    30. 	d1 := dog{
    31. 		age: 12,
    32. 		animal: animal{
    33. 			name: "老徐",
    34. 		},
    35. 	}
    36. 	d1.call()
    37. 	d1.eat()
    38. }
    39.  
    40. 名字叫老王的狗狗在吃饭
    41. 名字叫老徐的狗狗今年12岁
    42. 名字叫老徐的狗狗在吃饭

    1.14 练习

    1.14.1 学生管理系统（函数版）

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. 	"os"
    6. )
    7.  
    8. /*
    9. 学生版学生管理系统
    10. 系统能够查看、新增、删除学生
    11. */
    12.  
    13. // 定义学生结构体
    14. type student struct {
    15. 	id, age   int
    16. 	name, sex string
    17. }
    18.  
    19. var allStudent map[int]*student // 声明变量
    20.  
    21. // newStudent是student类型的构造函数
    22. func newStudent(id, age int, name, sex string) *student {
    23. 	return &student{
    24. 		id:   id,
    25. 		name: name,
    26. 		age:  age,
    27. 		sex:  sex,
    28. 	}
    29. }
    30.  
    31. // 展示学生
    32. func showAllStudent() {
    33. 	for key, value := range allStudent {
    34. 		fmt.Printf("学号:%d, 姓名:%s\n", key, value.name)
    35. 	}
    36. }
    37.  
    38. // 添加学生
    39. func addStudent() {
    40. 	// 创建一个新学生
    41. 	var (
    42. 		id, age   int
    43. 		name, sex string
    44. 	)
    45. 	// 获取用户输入
    46. 	fmt.Print("请输入学生学号>>>:")
    47. 	fmt.Scanln(&id)
    48. 	fmt.Print("请输入学生姓名>>>:")
    49. 	fmt.Scanln(&name)
    50. 	fmt.Print("请输入学生年龄>>>:")
    51. 	fmt.Scanln(&age)
    52. 	fmt.Print("请输入学生性别>>>:")
    53. 	fmt.Scanln(&sex)
    54. 	// 使用构造函数创建一个学生
    55. 	newStu := newStudent(id, age, name, sex)
    56. 	// 将新创建的学生添加到 allStudent 中
    57. 	allStudent[id] = newStu
    58. }
    59.  
    60. // 删除学生
    61. func deleteStudent() {
    62. 	var id int
    63. 	// 获取用户输入要删除学生的学号
    64. 	fmt.Print("请输入要删除学生的学号>>>:")
    65. 	fmt.Scanln(&id)
    66. 	delete(allStudent, id)
    67. 	fmt.Printf("\n学号是%d的学生已经被删除\n", id)
    68. }
    69.  
    70. func main() {
    71. 	allStudent = make(map[int]*student, 50) // 初始化
    72.  
    73. 	fmt.Println("欢迎光临学生管理系统")
    74. 	fmt.Println(`
    75. 		1.查看所有学生
    76. 		2.新增学生
    77. 		3.删除学生
    78. 		4.退出
    79. 	`)
    80. 	for {
    81. 		var choice int
    82. 		fmt.Print("请输入你想要的选项>>>:")
    83. 		fmt.Scanln(&choice)
    84. 		fmt.Printf("你选择了 %d 这个选项\n", choice)
    85. 		switch choice {
    86. 		case 1:
    87. 			showAllStudent()
    88. 		case 2:
    89. 			addStudent()
    90. 		case 3:
    91. 			deleteStudent()
    92. 		case 4:
    93. 			os.Exit(1)
    94. 		default:
    95. 			fmt.Println("滚 滚 滚 ~ ~ ~")
    96. 		}
    97. 	}
    98.  
    99. }

    1.15 结构体与JSON序列化

    JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。JSON键值对是用来保存JS对象的一种方式，键/值对组合中的键名写在前面并用双引号""包裹，使用冒号:分隔，然后紧接着值；多个键值之间使用英文,分隔。

    1. package main
    2.  
    3. import (
    4. 	"encoding/json"
    5. 	"fmt"
    6. )
    7.  
    8. type person struct {
    9. 	Name string `json:"name"`
    10. 	Age  int    `json:"age"`
    11. }
    12.  
    13. func main() {
    14. 	p1 := person{
    15. 		Name: "老王",
    16. 		Age:  38,
    17. 	}
    18. 	// 序列化
    19. 	bt, err := json.Marshal(p1)
    20. 	if err != nil {
    21. 		fmt.Printf("序列化失败，错误是%v\n", err)
    22. 	}
    23. 	fmt.Println(string(bt))
    24.  
    25. 	// 反序列化
    26. 	str1 := `{"name":"老王","age":38}`
    27. 	var p2 person
    28. 	json.Unmarshal([]byte(str1), &p2)
    29. 	fmt.Printf("%#v\n", p2)
    30.  
    31. }
    32.  
    33. {"name":"老王","age":38}
    34. main.person{Name:"老王", Age:38}

    注意：反引号里面不能有空格

    二. 接口

    在Go语言中接口（interface）是一种类型，一种抽象的类型。相较于之前章节中讲到的那些具体类型（字符串、切片、结构体等）更注重“我是谁”，接口类型更注重“我能做什么”的问题。接口类型就像是一种约定——概括了一种类型应该具备哪些方法，在Go语言中提倡使用面向接口的编程方式实现解耦。

    2.1 接口的类型

    接口是一种由程序员来定义的类型，一个接口类型就是一组方法的集合，它规定了需要实现的所有方法。

    相较于使用结构体类型，当我们使用接口类型说明相比于它是什么更关心它能做什么。

    2.1.1 接口的定义

    每个接口类型由任意个方法签名组成，接口的定义格式如下：

    1. type 接口类型名 interface{
    2.     方法名1( 参数列表1 ) 返回值列表1
    3.     方法名2( 参数列表2 ) 返回值列表2
    4.     …
    5. }

    • 接口类型名：Go语言的接口在命名时，一般会在单词后面添加er，如有写操作的接口叫Writer，有关闭操作的接口叫closer等。接口名最好要能突出该接口的类型含义。

    • 方法名：当方法名首字母是大写且这个接口类型名首字母也是大写时，这个方法可以被接口所在的包（package）之外的代码访问。

    • 参数列表、返回值列表：参数列表和返回值列表中的参数变量名可以省略。

    如，定义一个包含Write方法的Writer接口。

    1. type Writer interface{
    2.     Write([]byte) error
    3. }

    当你看到一个Writer接口类型的值时，你不知道它是什么，唯一知道的就是可以通过调用它的Write方法来做一些事情。

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. type animaler interface {
    6. 	sleep()
    7. 	eat(str string)
    8. }
    9.  
    10. type dog struct {
    11. 	name string
    12. 	age  int
    13. 	sex  string
    14. }
    15.  
    16. func (d dog) sleep() {
    17. 	fmt.Printf("名字叫%s的狗狗喜欢睡觉\n", d.name)
    18. }
    19.  
    20. func (d dog) eat(str string) {
    21. 	fmt.Printf("%s今年%d岁,喜欢啃骨头\n", str, d.age)
    22. }
    23.  
    24. func show(a animaler, str string) {
    25. 	a.eat(str)
    26. 	a.sleep()
    27. }
    28.  
    29. func main() {
    30. 	d1 := dog{
    31. 		name: "laowang",
    32. 		age:  3,
    33. 		sex:  "male",
    34. 	}
    35. 	show(d1, "哈士奇")
    36. }
    37.  
    38. 哈士奇今年3岁,喜欢啃骨头
    39. 名字叫laowang的狗狗喜欢睡觉
    1. package main
    2.  
    3. import "fmt"
    4.  
    5. // 定义接口类型
    6. type animal interface {
    7. 	move()
    8. 	eat(string)
    9. }
    10.  
    11. type cat struct {
    12. 	name string
    13. 	like string
    14. }
    15.  
    16. type chicken struct {
    17. 	name string
    18. }
    19.  
    20. // chicken结构体的两个方法
    21. func (c chicken) move() {
    22. 	fmt.Println("鸡只有两条腿，所以呢?跑的不快")
    23. }
    24.  
    25. func (c chicken) eat(food string) {
    26. 	fmt.Printf("我喜欢吃%s\n", food)
    27. }
    28.  
    29. // cat结构体的两个方法
    30. func (c cat) move() {
    31. 	fmt.Println("我们一起走猫步")
    32. }
    33.  
    34. func (c cat) eat(food string) {
    35. 	fmt.Printf("小猫喜欢吃%s\n", food)
    36. }
    37.  
    38. func main() {
    39. 	var a1 animal
    40.  
    41. 	c1 := cat{
    42. 		name: "球球",
    43. 		like: "喜欢玩耍",
    44. 	}
    45. 	a1 = c1
    46. 	a1.eat("鱼鱼")
    47.  
    48. 	c2 := chicken{
    49. 		name: "鸡大婶",
    50. 	}
    51.  
    52. 	var a2 animal
    53.  
    54. 	a2 = c2
    55. 	fmt.Printf("%T\n", a2)
    56.  
    57. }
    58.  
    59.  
    60. 小猫喜欢吃鱼鱼
    61. main.chicken

    2.2 值接收者和指针接收者

    2.2.1 值接收者

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. // 定义接口类型
    6. type animal interface {
    7. 	move()
    8. 	eat(string)
    9. }
    10.  
    11. type cat struct {
    12. 	name string
    13. 	like string
    14. }
    15.  
    16. func (c cat) move() {
    17. 	fmt.Println("走猫步....")
    18. }
    19.  
    20. func (c cat) eat(food string) {
    21. 	fmt.Printf("猫喜欢吃%s\n", food)
    22. }
    23.  
    24. func main() {
    25. 	var a1 animal
    26. 	c1 := cat{
    27. 		name: "老王",
    28. 		like: "小鱼",
    29. 	}
    30. 	c2 := &cat{
    31. 		name: "胖子",
    32. 		like: "小虾",
    33. 	}
    34. 	a1 = c1
    35. 	fmt.Println(a1)
    36. 	a1 = c2
    37. 	fmt.Println(a1)
    38.  
    39. }
    40.  
    41. {老王 小鱼}
    42. &{胖子 小虾}

    使用值接收者实现接口之后，不管是结构体是值类型还是对应指针类型的变量都可以赋值给该接口变量。  

    2.2.2 指针接收者

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. // 定义接口类型
    6. type animal interface {
    7. 	move()
    8. 	eat(string)
    9. }
    10.  
    11. type cat struct {
    12. 	name string
    13. 	like string
    14. }
    15.  
    16. func (c *cat) move() {
    17. 	fmt.Println("走猫步....")
    18. }
    19.  
    20. func (c *cat) eat(food string) {
    21. 	fmt.Printf("猫喜欢吃%s\n", food)
    22. }
    23.  
    24. func main() {
    25. 	var a1 animal
    26. 	c1 := &cat{
    27. 		name: "老王",
    28. 		like: "小鱼",
    29. 	}
    30. 	c2 := &cat{
    31. 		name: "胖子",
    32. 		like: "小虾",
    33. 	}
    34. 	a1 = c1
    35. 	fmt.Println(a1)
    36. 	a1 = c2
    37. 	fmt.Println(a1)
    38.  
    39. }
    40.  
    41. &{老王 小鱼}
    42. &{胖子 小虾}

    指针接收者实现接口只能存结构体指针类型的变量。

    2.3 类型与接口的关系

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. // 同一个结构体可以实现多个接口
    6. // 接口可以嵌套
    7.  
    8. // 方法1
    9. type mover interface {
    10. 	move()
    11. 	eater
    12. }
    13.  
    14. // 方法2
    15. type eater interface {
    16. 	eat(string)
    17. }
    18.  
    19. // 结构体
    20. type cat struct {
    21. 	name string
    22. 	like string
    23. }
    24.  
    25. // cat实现了move接口
    26. func (c *cat) move() {
    27. 	fmt.Println("走猫步....")
    28. }
    29.  
    30. // cat实现了eat接口
    31. func (c *cat) eat(food string) {
    32. 	fmt.Printf("猫喜欢吃%s", food)
    33. }
    34.  
    35. func main() {
    36.  
    37. }

    2.4 空接口

    空接口是指没有定义任何方法的接口类型。因此任何类型都可以视为实现了空接口。也正是因为空接口类型的这个特性，空接口类型的变量可以存储任意类型的值。

    定义格式如下，没要必要起名字。

    interface{}  // 空接口

    所有的类型都实现了空接口，也就是任意类型的变量都能保存到空接口中。

    1. package main
    2.  
    3. import "fmt"
    4.  
    5. // 空接口作为函数的参数
    6. func show(a interface{}) {
    7. 	fmt.Printf("value:%v, type:%T\n", a, a)
    8. }
    9.  
    10. func main() {
    11. 	m1 := make(map[string]interface{}, 10)
    12. 	m1["name"] = "老王"
    13. 	m1["age"] = 35
    14. 	m1["sex"] = "男"
    15. 	m1["married"] = true
    16. 	m1["hobby"] = [...]string{"唱歌", "跳舞", "睡觉"}
    17. 	fmt.Println(m1)
    18.  
    19. 	show(false)
    20. 	show(nil)
    21. 	show(25)
    22. }
    23.  
    24. map[age:35 hobby:[唱歌 跳舞 睡觉] married:true name:老王 sex:男]
    25. value:false, type:bool
    26. value:<nil>, type:<nil>
    27. value:25, type:int

    2.5 类型断言

    1. package main
    2.  
    3. import (
    4. 	"fmt"
    5. )
    6.  
    7. // 类型断言
    8. func assign(v interface{}) {
    9. 	v, ok := v.(string)
    10. 	if !ok {
    11. 		fmt.Println("类型错误")
    12. 	} else {
    13. 		fmt.Printf("这就是一个string类型:%v", v)
    14. 	}
    15. }
    16.  
    17. // 类型断言
    18. func assign2(v interface{}) {
    19. 	switch t := v.(type) {
    20. 	case string:
    21. 		fmt.Println("这是一个字符串,", t)
    22. 	case int:
    23. 		fmt.Println("这是一个int,", t)
    24. 	case bool:
    25. 		fmt.Println("这是一个布尔类型,", t)
    26. 	default:
    27. 		fmt.Println("这是一个其他类型,", t)
    28. 	}
    29. }
    30.  
    31. func main() {
    32. 	assign2([...]string{"hpl"})
    33. }
    34.  
    35. 类型错误
    36. 这是一个其他类型, [hpl]

    在 Go 语言中接口是一个非常重要的概念和特性，使用接口类型能够实现代码的抽象和解耦，也可以隐藏某个功能的内部实现，但是缺点就是在查看源码的时候，不太方便查找到具体实现接口的类型。

  • 相关阅读:
    Linux内核驱动开发-字符设备驱动框架
    前端vue使用onlyoffice控件实现word在线编辑、预览（仅列出前端部分需要做的工作，不包含后端部分）
    高并发研究
    使用 Python 的自主机器人算法 Dijkstra 路径规划
    【云原生】容器技术发展
    Jenkins共享库使用
    DAY47 198.打家劫舍 + 213.打家劫舍II + 337.打家劫舍 III
    县域农牧业信息化项目建设技术解决方案（完整版本）
    澳洲最热门职业，护士排第一，医生竟然不如程序员？
    李宁「向上」：不止缺一个FILA
  • 原文地址：https://blog.csdn.net/hpl980342791/article/details/125438251