5 map、结构体、方法、面向对象【Go语言教程】

最新推荐文章于 2023-06-10 10:09:54 发布
最新推荐文章于 2023-06-10 10:09:54 发布
阅读量623 收藏
点赞数
分类专栏： go 文章标签： golang 算法 教程 开发语言 编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45565886/article/details/130463174
版权

5 map、结构体、方法、面向对象【Go语言教程】

1 map

1.1 概念及声明

①概念

基本语法：var map 变量名 map[keytype]valuetype

  • key 可以是什么类型？
    golang 中的 map，的 key 可以是很多种类型，比如 bool, 数字，string, 指针, channel , 还可以是只包含前面几个类型的 接口, 结构体, 数组
    通常 key 为 int 、string
    注意: slice， map 还有 function 不可以，因为这几个没法用 == 来判断
  • valuetype 可以是什么类型？
    valuetype 的类型和 key 基本一样，这里我就不再赘述了通常为: 数字(整数,浮点数),string,map,struct

②声明方式

  1. var a map[string]string
  2. var a map[string]int
  3. var a map[int]string
  4. var a map[string]map[string]string
    注意：声明是不会分配内存的，初始化需要 make ，分配内存后才能赋值和使用
func main(){
	//map的声明和注意事项
	var a map[string]string
	//在使用map之前，需要先make（给map分配内存空间）
	a = make(map[string]string, 10)
	a["no1"] = "curry"
	a["no2"] = "徐杰"
	a["no3"] = "John"
	a["no4"] = "欧文"
	a["no3"] = "Bob"
	fmt.Println(a)
}

在这里插入图片描述

对上面的代码进行说明：

  1. map 在使用前一定要 make
  2. map 的 key 是不能重复，如果重复了，则以最后这个 key-value 为准
  3. map 的 value 是可以相同的.
  4. map 的 key-value 是无序
  5. make 内置函数数目

在这里插入图片描述
map的三种初始化方式：

package main
import (
	"fmt"
)

func main(){
	//map的初始化方式
	//1. 先声明后make
	var a map[string]string
	//在使用map前，需要先make（给map分配数据空间）
	a = make(map[string]string, 10)
	a["no1"] = "天暗星"
	a["no2"] = "天捷星"
	a["no3"] = "天速星"
	fmt.Println(a)
	//2. 声明时直接make
	cities := make(map[string]string)
	cities["no1"] = "newYork"
	cities["no2"] = "taibei"
	cities["no3"] = "beijing"
	fmt.Println(cities)
	//3. 声明时，直接初始化并赋值
	heros := map[string]string{
		"hero1": "宋江",
		"hero2": "赵云",
		"hero3": "岳飞",
	}
	heros["hero3"] = "林冲"
	fmt.Println("heros=", heros)
	// map[no1:天暗星 no2:天捷星 no3:天速星]
	// map[no1:newYork no2:taibei no3:beijing]     
	// heros= map[hero1:宋江 hero2:赵云 hero3:林冲]	
}

1.2 map的crud

①map的增加和更新

map[“key”] = value //如果 key 还没有，就是增加，如果 key 存在就是修改。

func main(){
	a := make(map[string]string)
	//map中没有存在key1，因此直接新增
	a["key1"] = "jack"
	//map中已经存在了key1，因此直接更新
	a["key1"] = "jackson"
	//map[key1:jackson]
	fmt.Println(a)
}

②map的删除

delete(map，“key”) ，delete 是一个内置函数，如果 key 存在，就删除该 key-value,如果 key 不存在， 不操作，但是也不会报错
在这里插入图片描述
在这里插入图片描述

func main(){
	a := make(map[string]string)
	a["key1"] = "jack"
	//删除key1
	delete(a, "key1")
	//map[]
	fmt.Println(a)
}
  • 注意：如果我们要删除 map 的所有 key ,没有一个专门的方法一次删除，可以遍历一下 key, 逐个删除或者 map = make(…)，make 一个新的，让原来的成为垃圾，被 gc 回收
    在这里插入图片描述
    ③map的查找
    在这里插入图片描述

对上面代码的说明:
说明：如果 heroes 这个 map 中存在 “no1” ， 那么 findRes 就会返回 true,否则返回 false

func main(){
	a := make(map[string]string)
	a["key1"] = "jack"
	a["key2"] = "tom"
	val, ok := a["key3"]
	if ok {
		fmt.Println("值为：", val)
	}else {
		fmt.Println("没找到")
	}
}

1.3 map的遍历与切片

①map的遍历

  • 案例演示相对复杂的 map 遍历：该 map 的 value 又是一个 map
    说明：map 的遍历使用 for-range 的结构遍历
package main
import (
	"fmt"
)

func main(){
	//map通过for-range方式来进行遍历
	//1. 遍历普通map
	cities := make(map[string]string)
	cities["no1"] = "北京"
	cities["no2"] = "天津"
	cities["no3"] = "上海"
	for k, v := range cities {
		fmt.Printf("k=%v v=%v\n", k, v)
	}
	//2. 遍历双重map【map的value又是一个map】
	studentMap := make(map[string]map[string]string)
	//map使用之前需要make make(map[string]string, 3)
	studentMap["stu01"] = make(map[string]string, 3)
	studentMap["stu01"]["name"] = "jack"
	studentMap["stu01"]["sex"] = "男"
	studentMap["stu01"]["address"] = "北京胡同"

	studentMap["stu02"] = make(map[string]string)
	studentMap["stu02"]["name"] = "lucy"
	studentMap["stu02"]["sex"] = "女"
	studentMap["stu02"]["address"] = "上海外滩"

	for k1, v1 := range studentMap {
		fmt.Println("k1=", k1)
		for k2, v2 := range v1 {
			fmt.Printf("\t k2=%v v2=%v\n", k2, v2)
		}
		fmt.Println()
	}
}

在这里插入图片描述
在这里插入图片描述
②map切片

切片的数据类型如果是 map，则我们称为 slice of map，map 切片，这样使用则 map 个数就可以动态变化了。

案例：

要求：使用一个 map 来记录 monster 的信息 name 和 age, 也就是说一个 monster 对应一个 map,并且妖怪的个数可以动态的增加=>map 切片

package main
import (
	"fmt"
)

func main(){
	//1. 声明一个map切片
	var monsters []map[string]string
	monsters = make([]map[string]string, 2) //准备放入2个妖怪
	monsters[0] = make(map[string]string, 2)
	monsters[0]["name"] = "牛魔王"
	monsters[0]["age"] = "500"

	monsters[1] = make(map[string]string, 2)
	monsters[1]["name"] = "狐狸精"
	monsters[1]["age"] = "300"
	//下面写法越界，因为只开辟了两块空间
	//panic: runtime error: index out of range [2] with length 2 
	// monsters[2] = make(map[string]string, 2)
	//这里我们可以使用切片的append函数，动态的增加monster
	//①定义monster信息
	newMonster := map[string]string{
		"name" : "新妖怪~火云邪神",
		"age" : "200",
	}
	monsters = append(monsters, newMonster)
	//[map[age:500 name:牛魔王] map[age:300 name:狐狸精] map[age:200 name:新妖怪~火云邪神]]
	fmt.Println(monsters)
}

1.3 map的排序及使用细节

①map的排序

  1. golang 中没有一个专门的方法针对 map 的 key 进行排序
  2. golang 中的 map 默认是无序的，注意也不是按照添加的顺序存放的，你每次遍历，得到的输出可能不一样.
  3. golang 中 map 的排序，是先将 key 进行排序，然后根据 key 值遍历输出即可
package main
import (
	"fmt"
	"sort"
)

func main(){
	//map的排序
	map1 := make(map[int]int, 10)
	map1[10] = 100
	map1[1] = 13
	map1[4] = 56
	map1[0] = 90

	fmt.Println(map1)

	//map的排序：
	//1. 先将map的key放入到切片中
	//2. 对切片进行排序
	//3. 遍历切片，然后按照key来输出map的值
	var keys []int
	for k, _ := range map1 {
		keys = append(keys, k)
	}
	//排序
	sort.Ints(keys)
	//根据排序后的切片输出map中key对应的value
	for _, k := range keys {
		fmt.Printf("map1[%v]=%v \n", k, map1[k])
	}
}

在这里插入图片描述
②使用细节

  1. map 是引用类型，遵守引用类型传递的机制，在一个函数接收 map，修改后，会直接修改原来的 map
    在这里插入图片描述
  1. map 的容量达到后，再想 map 增加元素，会自动扩容，并不会发生 panic，也就是说 map 能动态的增长 键值对(key-value)
  2. map 的 value 也经常使用 struct 类型，更适合管理复杂的数据(比前面 value 是一个 map 更好)，比如 value 为 Student 结构体
    在这里插入图片描述

2 结构体（面向对象特性）

2.1 概念

Golang中面向对象的特点：

  1. Golang 也支持面向对象编程(OOP)，但是和传统的面向对象编程有区别，并不是纯粹的面向对象语言。所以我们说 Golang 支持面向对象编程特性是比较准确的。

  2. Golang 没有类(class)，Go 语言的结构体(struct)和其它编程语言的类(class)有同等的地位，你可以理解 Golang 是基于 struct 来实现 OOP 特性的。

  3. Golang 面向对象编程非常简洁，去掉了传统 OOP 语言的继承、方法重载、构造函数和析构函数、隐藏的 this 指针等等

  4. Golang 仍然有面向对象编程的继承，封装和多态的特性，只是实现的方式和其它 OOP 语言不一样，比如继承 ：Golang 没有 extends 关键字，继承是通过匿名字段来实现。

  5. Golang 面向对象(OOP)很优雅，OOP 本身就是语言类型系统(type system)的一部分，通过接口(interface)关联，耦合性低，也非常灵活。后面同学们会充分体会到这个特点。也就是说在Golang 中面向接口编程是非常重要的特性。

结构体变量(实例)在内存的布局(重要!)
在这里插入图片描述

2.2 声明、使用及注意细节

①声明

type 结构体名称 struct { 
	field1 type
	field2 type

}
  1. 从概念或叫法上看： 结构体字段 = 属性 = field （即授课中，统一叫字段)
  2. 字段是结构体的一个组成部分，一般是基本数据类型、数组,也可是引用类型。比如我们前面定义猫结构体 的 Name string 就是属性

②使用

package main
import (
	"fmt"
	_ "sort"
)

//首字母大写表明公有
type Person struct {
	Name string
	Age int
	slice []int //切片
	map1 map[string]string //map
}

func main(){
	//1. 直接声明
	var person Person 
	person.slice = make([]int, 5)
	person.map1 = make(map[string]string)
	fmt.Println("person=", person)

	//2. 直接声明并初始化 {}
	var person2 Person = Person{"jack", 20, make([]int, 5), make(map[string]string)}
	fmt.Println("person2=", person2)
	// person3 := Person{"jucy", 0, make([]int, 5), make(map[string]string)}
	// fmt.Println("person3=", person3)

	//3. &
	var p3 *Person = new(Person)
	//因为p3是一个指针， 因此：
	//(*)p3.Name = "smith" 也可以这样写 p3.Name = "smith"
	//go的设计者为了程序员使用方便，所以在底层帮我们做了封装，底层会对 p3.Name = "smith"进行处理，会变为(*p3).Name
	(*p3).Name = "smith"
	p3.Name = "john"
	fmt.Println("person3=", p3)

	//4. {}
	var p4 *Person = &Person{}
	(*p4).Name = "scott"
	p4.Name = "scott~~"
	fmt.Println("person4=",*p4)
}

在这里插入图片描述

③注意细节

  1. 字段声明语法同变量，示例：字段名 字段类型
  2. 字段的类型可以为：基本类型、数组或引用类型
  3. 在创建一个结构体变量后，如果没有给字段赋值，都对应一个零值(默认值)，规则同前面讲的一样:
    布尔类型是 false ，数值是 0 ，字符串是 “”。
    数组类型的默认值和它的元素类型相关，比如 score [3]int 则为[0, 0, 0]
    指针，slice，和 map 的零值都是 nil ，即还没有分配空间。
    在这里插入图片描述
  1. 不同结构体变量的字段是独立，互不影响，一个结构体变量字段的更改，不影响另外一个, 结构体是值类型。

注意：

  1. 结构体的所有字段在内存中是连续的
  2. 结构体是用户单独定义的类型，和其它类型进行转换时需要有完全相同的字段(名字、个数和类型)
  3. 结构体进行 type 重新定义(相当于取别名)，Golang 认为是新的数据类型，但是相互间可以强转
  4. struct 的每个字段上，可以写上一个 tag, 该 tag 可以通过反射机制获取，常见的使用场景就是序列化和反序列化。

序列化使用场景：
在这里插入图片描述

package main
import (
	"fmt"
	"encoding/json"
)

//前后端传输过程中，前端更希望字段名为小写，但是go语言如果为了让其他包能访问到字段只能
//首字母大写，因此就需要struct的tag来完成
type Monster struct {
	Name string `json:"name"` //`json:"name"`就是strcut tag
	Age int `json:"age"`
	Skill string `json:"skill"`
}


func main(){
	monster := Monster{"牛魔王", 500, "芭蕉扇~"}
	//将monster变量序列化为json格式字符串
	//json.Marshal 函数中使用反射
	jsonStr, err := json.Marshal(monster)
	if err != nil {
		fmt.Println("json处理错误 ", err)
	} 
	//jsonStr {"name":"牛魔王","age":500,"skill":"芭蕉扇~"}
	fmt.Println("jsonStr", string(jsonStr))
}

3 方法

3.1 介绍

在某些情况下，我们要需要声明(定义)方法。比如 Person 结构体:除了有一些字段外( 年龄，姓名…),Person 结构体还有一些行为比如:可以说话、跑步…,通过学习，还可以做算术题。这时就要用方法才能完成。

  • Golang 中的方法是作用在指定的数据类型上的(即：和指定的数据类型绑定)，因此自定义类型， 都可以有方法，而不仅仅是 struct。

3.2 方法的声明和调用

package main
import (
	"fmt"
)

type Person struct {
	Name string
}

//给Person绑定一个方法[绑定之后只有Person才能使用]
func (p Person) test(){
	fmt.Println("test() name=", p.Name)
}

func main(){
	var p Person
	p.Name = "tom"
	p.test()//调用方法
}
  1. test 方法和 Person 类型绑定
  2. test 方法只能通过 Person 类型的变量来调用，而不能直接调用，也不能使用其它类型变量来调
    用
  3. func (p Person) test() {}… p 表示哪个 Person 变量调用，这个 p 就是它的副本, 这点和函数传参非常相似。
  4. p 这个名字，有程序员指定，不是固定, 比如修改成 person 也是可以

3.3 方法的调用和传参机制（重要）

方法的调用和传参机制和函数基本一样，不一样的地方是方法调用时，会将调用方法的变量，当做实参也传递给方法。下面我们举例说明。

例如：getSum的方法过程
在这里插入图片描述

说明:

  1. 在通过一个变量去调用方法时，其调用机制和函数一样
  2. 不一样的地方时，变量调用方法时，该变量本身也会作为一个参数传递到方法(如果变量是值类型，则进行值拷贝，如果变量是引用类型，则进行地址拷贝)

3.4 注意事项

①声明和定义

func (recevier type) methodName（参数列表） (返回值列表){
方法体
return 返回值
}

  1. 参数列表：表示方法输入
  2. recevier type : 表示这个方法和 type 这个类型进行绑定，或者说该方法作用于 type 类型
  3. receiver type : type 可以是结构体，也可以其它的自定义类型
  4. receiver : 就是 type 类型的一个变量(实例)，比如 ：Person 结构体 的一个变量(实例)
  5. 返回值列表：表示返回的值，可以多个
  6. 方法主体：表示为了实现某一功能代码块
  7. return 语句不是必须的。

②注意事项和细节

  1. 结构体类型是值类型，在方法调用中，遵守值类型的传递机制，是值拷贝传递方式
  2. 如程序员希望在方法中，修改结构体变量的值，可以通过结构体指针的方式来处理
  3. Golang 中的方法作用在指定的数据类型上的(即：和指定的数据类型绑定)，因此自定义类型， 都可以有方法，而不仅仅是 struct， 比如 int , float32 等都可以有方法
  4. 方法的访问范围控制的规则，和函数一样。方法名首字母小写，只能在本包访问，方法首字母大写，可以在本包和其它包访问。
  5. 如果一个类型实现了 String()这个方法，那么 fmt.Println 默认会调用这个变量的 String()进行输出【类比java中重写了toString方法】

3.5 方法和函数的区别

  1. 调用方式不一样
    函数的调用方式: 函数名(实参列表)
    方法的调用方式: 变量.方法名(实参列表)
  2. 对于普通函数，接收者为值类型时，不能将指针类型的数据直接传递，反之亦然
  3. 对于方法（如 struct 的方法），接收者为值类型时，可以直接用指针类型的变量调用方法，反过来同样也可以
package main

import (
	"fmt"
)

type Person struct {
	Name string
}

//对于方法（如：struct的方法）
//接收者为值类型时，可以直接使用指针类型的变量调用方法，反过来也同样可以

//1. 和结构体类型绑定
func (p Person) test03(){
	p.Name = "jack"
	fmt.Println("test03()=", p.Name)
}

//2. 和指针类型绑定
func (p *Person) test04(){
	p.Name = "mary"
	fmt.Println("test04()=", p.Name)
}



func main(){
	var p Person
	p.Name = "tom"
	p.test03()
	fmt.Println("main() p.Name=", p.Name) //tom

	(&p).test03() //从形式上看是传入地址，但是本质上仍然是值拷贝【因为test03方法是和结构体绑定的】
	fmt.Println("main() p.Name=", p.Name) //tom

	(&p).test04()
	fmt.Println("main() p.Name=", p.Name) //mary
	p.test04() //等价(&p).test04(),从形式上是传入值类型，但是本质仍然是地址拷贝
	//【调用方不决定，决定权在调用的方法和什么绑定】

}

总结:

  1. 不管调用形式如何，真正决定是值拷贝还是地址拷贝，看这个方法是和哪个类型绑定.
  2. 如果是和值类型，比如 (p Person) , 则是值拷贝， 如果和指针类型，比如是 (p *Person) 则是地址拷贝。

3.6 工厂模式（类比get、set）

在java中为了访问私有的属性，通常会提供对应的get、set方法，但是Go中并没有；因此我们可以使用工厂模式来达到类似的效果

  • Golang 的结构体没有构造函数，通常可以使用工厂模式来解决这个问题。
一个结构体的声明是这样的: 
package model
type Student struct { 
	Name string...
}

因为这里的Student 的首字母S 是大写的，如果我们想在其它包创建 Student 的实例(比如main 包)， 引入 model 包后，就可以直接创建 Student 结构体的变量(实例)。但是问题来了，如果首字母是小写的， 比如 是 type student struct {…} 就不不行了，怎么办—> 工厂模式来解决.

  1. model包中定义一个结构体student

main.go:

package model

//定义一个私有的结构体
//Name字段是共有的，age字段是私有的
type student struct {
	Name string
	age int
}

//工厂模式：类比构造函数
//返回Student指针类型
func NewStudent(name string, age int) *student{
	return &student{
		Name: name,
		age: age,
	}
}

//工厂模式定义student对应的方法：类比get、set方法
func (stu *student) GetAge() int{
	return (*stu).age
}

func (stu *student) SetAge (age int) {
	(*stu).age = age
}
  1. 在main包下使用student

hello.go

package main

import (
	"fmt"
	"go_code/project01/main/model"
)

func main(){
	//创建一个student
	var stu = model.NewStudent("tom", 20)
	stu.SetAge(17)
	//因为Name在model中是首字母大写表明是公有的，因此可以直接访问；而age需要通过GetAge函数实现
	//tom 17
	fmt.Println(stu.Name, stu.GetAge())
}

在这里插入图片描述

4 面向对象

4.1 面向对象练习题（封装）

  1. 创建程序,在 model 包中定义 Account 结构体：在 main 函数中体会 Golang 的封装性。
  2. Account 结构体要求具有字段：账号（长度在 6-10 之间）、余额(必须>20)、密码（必须是六
  3. 通过 SetXxx 的方法给 Account 的字段赋值。(同学们自己完成
  4. 在 main 函数中测试
  1. 定义account结构体
package model

import (
	"fmt"
)

type account struct {
	accountNo string //账户
	Balance float64	//余额
	Password string
}

//使用工厂方法完成构造
func NewAccount(accountNo string, Balance float64, Password string) *account {
	if len(accountNo) < 6 || len(accountNo) > 10 {
		fmt.Println("账号必须在6-10之间...")
		return nil
	}
	if Balance < 20 {
		fmt.Println("余额不能少于20...")
		return nil
	}
	if len(Password) != 6 {
		fmt.Println("密码必须是6位..")
		return nil
	}
	account := account{
		accountNo: accountNo,
		Balance: Balance,
		Password: Password,
	}
	fmt.Println("创建账户成功~~~")
	return &account
}

//定义get方法[与结构体绑定]
func (a account) GetAccountNo() string{
	return a.accountNo
}

//set方法[与指针绑定]
func (a *account) SetAccountNo(accountNo string){
	(*a).accountNo = accountNo
}
  1. 使用
package main

import (
	"fmt"
	"go_code/project01/main/model"
)

func main(){
	//创建一个账户
	var account = model.NewAccount("4131341324", 35.5, "348291")
	fmt.Println("账户No=", account.GetAccountNo())
	account.SetAccountNo("6666666666")
	fmt.Println("新的账户No=", account.GetAccountNo())
}

结果：
在这里插入图片描述

4.2 面向对象（继承）

①概念

在这里插入图片描述

继承的优点：

  1. 代码的复用性提高了
  2. 代码的扩展性和维护性提高了
type Goods struct { Name string Price int
}
type Book struct {
//这里就是嵌套匿名结构体 Goods Writer string
	Goods	
}
②使用及注意点

继承的深入讨论：

  1. 结构体可以使用嵌套匿名结构体所有的字段和方法，即：首字母大写或者小写的字段、方法， 都可以使用。【举例说明】
package main

import (
	"fmt"
	_ "go_code/project01/main/model"
)

type A struct {
	Name string
	age int
}

//公有
func (a *A) SayOk(){
	fmt.Println("A SayOk ", a.Name)
}

//私有
func (a *A) hello(){
	fmt.Println("A hello", a.Name)
}


type B struct {
	//B继承了A
	A
}

func main(){
	var b B
	b.A.Name = "tom"
	//b.Name = "jack" //两种写法均可
	b.age = 12
	b.SayOk()
	b.hello()
}
  1. 匿名结构体字段访问可以简化
	b.A.Name = "tom"
	//b.Name = "jack" //两种写法均可

对上面的代码小结
(1) 当我们直接通过 b 访问字段或方法时，其执行流程如下比如 b.Name
(2) 编译器会先看 b 对应的类型有没有 Name, 如果有，则直接调用 B 类型的 Name 字段
(3) 如果没有就去看 B 中嵌入的匿名结构体 A 有没有声明 Name 字段，如果有就调用,如果没有继续查找…如果都找不到就报错.

  1. 当结构体和匿名结构体有相同的字段或者方法时，编译器采用就近访问原则访问，如希望访问匿名结构体的字段和方法，可以通过匿名结构体名来区分【举例说明】
    在这里插入图片描述
  2. 结构体嵌入两个(或多个)匿名结构体，如两个匿名结构体有相同的字段和方法(同时结构体本身没有同名的字段和方法)，在访问时，就必须明确指定匿名结构体名字，否则编译报错。【举例说明】
    在这里插入图片描述
  3. 如果一个 struct 嵌套了一个有名结构体，这种模式就是组合，如果是组合关系，那么在访问组合的结构体的字段或方法时，必须带上结构体的名字
    在这里插入图片描述
    在这里插入图片描述
  4. 嵌套匿名结构体后，也可以在创建结构体变量(实例)时，直接指定各个匿名结构体字段的值
package main

import (
	"fmt"
	_ "go_code/project01/main/model"
)

type Goods struct {
	Name string
	Price float64
}

type Brand struct {
	Name string
	Address string
}

type TV struct {
	Goods
	Brand
}

type TV2 struct {
	*Goods
	*Brand
}


func main(){
	//嵌套匿名结构体后，也可以在创建结构体变量（实例）时，直接指定各个匿名结构体字段的值
	tv := TV{Goods{"电视机", 5000.99}, Brand{"海尔", "山东"}}
	tv2 := TV{
		Goods{
			Price: 6999.99,
			Name: "电视机002",
		},
		Brand{
			Name: "夏普",
			Address: "北京",
		},
	}
	fmt.Println("tv=", tv)
	fmt.Println("tv2=", tv2)

	tv3 := TV2{
		&Goods{
			Name: "电视机003",
			Price: 79999.99,
		},
		&Brand{
			Name: "长虹",
			Address: "四川",
		},
	}
	fmt.Println("tv3=", *(tv3.Goods), *(tv3.Brand))
}

在这里插入图片描述7. 结构体的匿名字段是基本数据类型，如果需要有多个 int 的字段，则必须给 int 字段指定名字

package main

import (
	"fmt"
	_ "go_code/project01/main/model"
)

type Monster struct {
	Name string
	Age int
}

type E struct {
	Monster
	int //匿名字段的基本数据类型
	n int
}


func main(){
	//匿名字段是基本数据类型的使用
	var e E
	e.Name = "狐狸精"
	e.Age = 300
	e.int = 20
	e.n = -50
	//e= {{狐狸精 300} 20 -50}
	fmt.Println("e=",e)

}
③多重继承

如一个 struct 嵌套了多个匿名结构体，那么该结构体可以直接访问嵌套的匿名结构体的字段和方法，从而实现了多重继承。

在这里插入图片描述

多重继承细节说明

  1. 如嵌入的匿名结构体有相同的字段名或者方法名，则在访问时，需要通过匿名结构体类型名来区分。【案例演示】
    在这里插入图片描述

  2. 为了保证代码的简洁性，建议大家尽量不使用多重继承

NPE~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Go语言指针访问结构体的方法
09-22
主要介绍了Go语言指针访问结构体的方法,涉及Go语言指针及结构体的使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下
C++结构体非面向对象特性
01-20
结构体部分的学习也是面向对象中类的基础。结构体定义将会在C++程序中形成一种类型的概念，用于开发者创建其对象实例使用。C++中结构体定义的一般语法形式： 　struct struct_name //声明结构体名称为struct_name ...
Go map 存储对象
wgchen
06-10 241
Go map 存储对象
Go语言的map详细总结（第一篇）
Dong_chongwu的博客
02-10 2878
Go语言的map详解，包括Go语言map的底层机制，哈希碰撞，key的定位过程，以及map的扩容条件及机制，map的并发安全性以及如何比较两个map相等.....
GO语言中的Map使用详解
金戈鐡馬
11-18 1万+
Go语言中的map(映射、字典)是一种内置的数据结构，它是一个无序的key-value对的集合，比如以身份证号作为唯一键来标识一个人的信息。Go语言中并没有提供一个set类型，但是map中的key也是不相同的，可以用map实现类似set的功能。
[Go语言入门] 10 Go语言Map详解
时空旅客的专栏
07-10 1796
Go语言入门, Go语言Map
Go语言学习第六课---map与结构体
陈c
03-19 692
文章目录一、map1.1 概述1.2 创建map1.3 map的增删改查二、结构体2.1 概述2.2 结构体创建2.3 结构体的比较2.3 结构体作为函数参数 一、map 1.1 概述  map 是一种特殊的数据结构：一种元素对（pair）的无序集合，pair 的一个元素是 key，对应的另一个元素是 value，所以这个结构也称为关联数组或字典。这是一种快速寻找值的理想结构：给定 key，对应的 value 可以迅速定位。   map 这种数据结构在其他编程语言中也称为字典（Python）、hash 和
Go语言中结构体方法副本传参与指针传参的区别介绍
01-03
GO语言结构体方法跟结构体指针方法的区别 首先，我定了三个接口、一个结构和三个方法： type DeptModeA interface { Name() string SetName(name string) } type DeptModeB interface { Relocate(building string, ...
go语言结构体转换map、map转换结构体、json字符串转结构体、结构体数据转换到别的结构体
01-07
1.结构体转map 2.map转结构体 3.结构体数据转移到结构体 4.json字符串转结构体 package main import ( encoding/json fmt reflect ) type User struct { Name string `json:name` Age int `json:age` } func ...
Go语言教程之结构体
01-20
闲话不多说，今天给大家继续分享关于Go语言的教程知识之结构体。 对象 在介绍结构体之前，我们先讲讲编程语言中的对象的概念吧，因为在相关的程序开发过程中，我们通常是面向对象进行编程，就是将相关的属性和方法...
Go语言基础之结构体
CrazyDemo的博客
10-23 340
类型别名和自定义类型 自定义类型 Go语言使用type来自定义类型，自定义类型是定义了一个全新的类型 type NewInt int 类型别名 使用type和=来进行类型别名定义 type TypeAlisa = Type 自定义类型和类型别名区别 //NewInt 基于int的自定义类型 type NewInt int //MyInt 为类型别名 typ...
go的数组和map默认是地址引用，对象是值引用，和对象初始化
weixin_43292547的博客
09-03 198
【代码】go的数组和map默认是地址引用，对象是值引用。
golang中struct、json、map互相转化
热门推荐
小拳头的博客
05-07 9万+
一、Json和struct互换（1）Json转struct例子：package main import ( "fmt" "encoding/json" ) type People struct { Name string `json:"name_title"` Age int `json:"age_size"` } func J...
Golang 接口切片存储多层嵌套Map对象，如何初始化，又如何直接读取嵌套层的key-value值
zhengzizhi的专栏
07-01 8477
接口切片存储多层嵌套Map对象，如何初始化，又如何直接读取嵌套层的key-value值
go语言基础（三）：map、结构体
alin的博客
10-26 2031
go语言基础（三）：map、结构体 1. map 语法：var map的名字 map[键类型]值类型 = make(map[键类型]值类型) map的名字 := make(map[键类型]值类型) 如果不写后面的make的话会报错 map在定义后不需要给它指定大小就能进行使用，和切片这一点不同要区分 对于map直接使用map名[键值]=数据值，就可以进行数据的添加 func main() { var m map[int]string = make(map[int]string) m[0] =
Go语言Map详解
码墨
08-24 1万+
map(字典、哈希表、映射)是一种使用频率很高的数据结构，将其作为语言的内置类型，从运行时层面进行优化，可获得更好的性能。 一、内部实现 map的源码结构为: // A header for a Go map. type hmap struct { // Note: the format of the Hmap is encoded in ../../cmd/internal/gc/...
go语言中的map类型
Learning
06-21 5211
定义： map是一种映射，在go中是散列表的引用，类型是map[key_type] value_type。 map的键必须是可以通过操作符== 来比较的数据类型。 非零值的两个map变量之间不可比较 特殊值： 零值：nil map变量可以和零值比较 主要操作： |操作|代码形式|备注| |-|-|-| |删除|delete(map_var, map_key)|-| |查找|map...
golang中map声明及初始化
lnsx的博客
12-03 1万+
map的声明 var m1 map[string]int map[key]value   key必须支持==（避免使用浮点型）value不做规范 map的初始化 方式1 var m1 map[string]int=map[sting]int{"key":0} 方式2 m2:=make(map[string]int) 注意： map声明后不能进行赋值，只有初始化后才能进行赋值操作
std map 结构体
最新发布
08-05
在引用中的代码示例中，展示了如何使用std::map来存储自定义结构体Test作为键，并将字符串作为值存储在map中。Test结构体包含了两个整数成员x和y，并实现了一个重载小于操作符的函数。通过迭代map，我们可以输出Test...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值