文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

Go语言之结构体与方法

2024-04-02 19:55

关注

一、结构体

结构体是一系列属性的集合(类似于 Python 中的类)

1、结构体的定义与使用


// 定义
type Person struct {
   Name string
   Age int
   Sex string
}

func main() {
   // 使用
   var per Person
   per.Name="XiaoYang"
   fmt.Println(per)
}

2、定义并赋初值


type Person struct {
   Name string
   Age  int
   Sex  string
}

func main() {
   var per1 Person = Person{Name: "XiaoYang"}         // 按关键字传参,可以少传
   var per2 Person = Person{"Bob", 20, "男"}  // 按位置传参,全传

   fmt.Println(per1) // 输出:{XiaoYang 0 }
   fmt.Println(per2) // 输出:{Bob 20 男}
}

3、匿名结构体(只使用一次,没有名字)


// 定义个匿名结构体并实例化之后赋值给了 hobby 变量
hobby := struct {
   HobbyId   int
   HobbyName string
}{HobbyId: 1, HobbyName: "篮球"}

fmt.Println(hobby)  // 输出:{1 篮球}
fmt.Println(hobby.HobbyName) // 输出:篮球

4、结构体的零值

定义好的结构体没有被初始化时,该结构体的字段将默认赋值为零值

也就是我属性的零值,所以他是值类型,参数传递,copy 传递,在函数中修改不会影响原来的


type Person struct {
   Name string
   Age  int
   Sex  string
}

func main() {
   var per Person=Person{"Bob", 20, "男"}
    
   fmt.Println(per) // 输出:{Bob 20 男}
   test(per)  // 输出:{Bob 20 男}
   fmt.Println(per) // 输出:{Bob 20 男}
}

func test(per Person)  {
   per.Age=20
   fmt.Println(per)
}

5、结构体的指针


// & 放在变量前,表示取该变量的地址
// * 放在类型前,表示指向该类型的指针(变量定义,指定类型时才会用到) *[3]int  和 [3]*int
// * 放在变量前,表示解引用(取出指针指向的具体的值)


type Person struct {
 Name string
 Age  int
 Sex  string
}

func main() {
 var per1 *Person
 fmt.Println(per1) // 输出:<nil>  表示指针类型

 // 定义并初始化
 var per2 *Person = &Person{}
 fmt.Println(per2) // 输出:&{ 0 }
    
 // 把per2的名字改成XiaoYang
 (*per2).Name = "XiaoYang"
    
 // 也支持直接使用
 per2.Name = "Bob"
 fmt.Println(per2) // 输出:&{Bob 0 }

}

6、匿名字段(字段没有名字,只有类型)

可用于【变量提升 / 提升字段】类似于面向对象的继承


// 定义一个结构体,匿名字段类型就是字段名字,所有类型不能重复
type Person struct {
   string
   int
   Sex  string
}

func main() {
   per := Person{"XiaoYang", 20, "男"} // 字段匿名,类型就是字段名
   fmt.Println(per)   // 输出:{XiaoYang 20 男}
   fmt.Println(per.string) // 输出:XiaoYang
}

7、嵌套结构体(结构体中套结构体)


type Person struct {
   Name  string
   Age   int
   Sex   string
   Hobby Hobby       // Person中嵌套Hobby结构体字段
}

type Hobby struct {
   HobbyId   int
   HobbyName string
}

func main() {
   per := Person{Name:"XiaoYang", Age: 20, Sex: "男", Hobby: Hobby{1,"篮球"}}
    
   fmt.Println(per)  // 输出:{XiaoYang 20 男 {1 篮球}}
   fmt.Println(per.Name) // 输出:XiaoYang
   fmt.Println(per.Hobby.HobbyName) // 输出:篮球
}

8、字段提升

结构体中有匿名的结构体类型字段,则该匿名结构体里的字段就称为提升字段,可以从外部直接访问


type Person struct {
   Name  string
   Age   int
   Sex   string
   Hobby     // Person中嵌套Hobby匿名结构体字段
}

type Hobby struct {
   HobbyId   int
   HobbyName string
}

func main() {
   per := Person{Name:"XiaoYang", Age: 20, Sex: "男", Hobby: Hobby{1,"篮球"}}
   
   // 打印爱好的名字(Hobby是一个匿名字段,会字段提升)
   fmt.Println(per.HobbyName)   // 输出:篮球
    
   // per.hobby 类似于面向对象中的super()
   fmt.Println(per.Hobby.HobbyName)  // 输出:篮球
}


// ------------------------------------------------------------------------------------


// 当子类和父类中的字段名一样时,就像面向对象的继承,子类继承父类(结构体嵌套,匿名字段),子类可以直接调用父类中的属性或方法

type Person struct {
   Name  string
   Age   int
   Sex   string
   Hobby     // Person中嵌套Hobby匿名字段
}

type Hobby struct {
   HobbyId   int
   Name      string
}

func main() {
   per := Person{Name:"XiaoYang", Age: 20, Sex: "男", Hobby: Hobby{1,"篮球"}}
   
   fmt.Println(per.Name)  // 输出:XiaoYang ——>优先使用自己的
   fmt.Println(per.Hobby.Name)  // 输出:篮球    ——>指定打印Hobby的名字
}

9、结构体相等性

结构体是值类型。

如果它的每一个字段都是可比较的,则该结构体也是可以比较的。

如果两个结构体变量的对应字段相等,则两个变量也是相等的。

如果结构体包含不可比较的字段,则结构体变量也不可比较。


type Person struct {
   Name string
   Age  int
   Sex  string
   // 包含不可比较的字段
   Test []int ——>这是引用类型不可比较
}

func main() {
   // 值类型可以直接==比较,引用类型只能跟nil用==比较
   per1 := Person{Name: "XiaoYang"}
   per2 := Person{Name: "XiaoYang"}
   per3 := Person{Name: "XiaoYang", Age: 20}
    
   fmt.Println(per1 == per2)  // 输出:ture ——>包含不可比较类型都会直接报错
   fmt.Println(per1 == per3)  // 输出:false
}

二、方法

方法就是一个特殊函数,在函数的基础上加了一些东西

func这个关键字和方法名中间加入一个特殊的接收器类型,接收器可以是结构体类型,也可以是非结构体类型

1、方法的定义和使用


type Person struct {
   Name string
   Age  int
   Sex  string
}

// 定义一个方法:给Person结构体绑定一个方法,oneself(名字随便取)类似于Python类中的self
func (oneself Person) printName()  {
   // 在方法内使用oneself
   fmt.Println(oneself.Name)
}

func main() {
   // 使用,对象调用方法
   per := Person{}
   per.Name = "XiaoYang"
   // 绑定给对象的方法
   per.printName()       // 输出:XiaoYang
}

2、有了函数为啥还需要方法?

方法功能都能实现,但是呢?它就能指定给某个对象了 。


type Person struct {
   Name string
   Age  int
   Sex  string
}

// 方法
func (oneself Person) printName() {
   fmt.Println(oneself.Name)
}

// 函数
func printName(oneself Person)  {
   fmt.Println(oneself.Name)
}

func main() {
   per := Person{Name: "XiaoYang"}

   per.printName()  // 方法的特殊之处,可以自动传递值
   printName(per)  // 函数需要手动传递值
}

3、指针接收器与值接收器


type Person struct {
   Name string
   Age  int
   Sex  string
}

// 值接收器修改名字
func (oneself Person) changeName(name string) {
   oneself.Name = name
}

// 指针接收器修改年龄
func (oneself *Person) changeAge(age int) {
   oneself.Age = age
}

func main() {
   per := Person{Name: "XiaoYang", Age: 20}
   fmt.Println(per)  // 输出:{XiaoYang 20 }

   per.changeName("Bob")// 由于这个是值接收器,它是copy一份传递过去所以修改的是copy的不会改掉原来的
   per.changeAge(18)    // 指针接收器,它传递的是指针

   fmt.Println(per)  // 输出:{XiaoYang 18 }
}


5、匿名字段的方法(方法提升)


type Person struct {
   Name  string
   Age   int
   Sex   string
   Hobby // 匿名字段
}

type Hobby struct {
   Id   int
   Name string
}

// 打印Person的名字
func (oneself Person) printName() {
   fmt.Println(oneself.Name)
}

// 打印Hobby的名字
func (oneself Hobby) printHobbyName() {
   fmt.Println(oneself.Name)
}

// 打印Hobby的名字
func (oneself Hobby) printName() {
   fmt.Println(oneself.Name)
}

func main() {
   per := Person{Name: "XiaoYang", Hobby: Hobby{1, "篮球"}}
   per.printName()      // 输出:XiaoYang
   per.printHobbyName() // 输出:篮球

   // 如果方法重名了,优先使用结构体自己的
   per.printName()       // 输出:XiaoYang
   per.Hobby.printName() // 输出:篮球
}

6、在方法中使用值接收器 与 在函数中使用值参数


type Person struct {
 Name string
 Age  int
 Sex  string
}

// 在方法中使用值接收器
func (oneself Person) printName() {
 fmt.Println(oneself.Name)
}

// 在函数中使用值参数
func printName(oneself Person) {
 fmt.Println(oneself.Name)
}

func main() {
 per1 := &Person{Name: "XiaoYang"} // per1是个指针
 per2 := Person{Name: "Bob"}

 printName(*per1) // 输出:XiaoYang
 per1.printName() // 输出:XiaoYang  ———> 值收器:可以用值来调,也可以用指针来调
 per2.printName() // 输出:Bob
}

7、在方法中使用指针接收器 与 在函数中使用指针参数


type Person struct {
   Name string
   Age  int
   Sex  string
}

// 在方法中使用指针接收器
func (oneself *Person) printName() {
   fmt.Println(oneself.Name)
}

func (oneself *Person)changeName(name string)  {
   oneself.Name=name

}

// 在函数中使用指针参数
func printName(oneself *Person) {
   fmt.Println(oneself.Name)
}

func main() {
   per1 := Person{Name: "XiaoYang"} 
   per2 := &Person{Name: "Bob"}   // per1是个指针

   per1.printName()   // 值可以调用
   printName(&per1)

   per2.printName()   // 指针可以调用
   printName(per2)


   per1.changeName("Alen")    // 可以修改
   fmt.Println(per1)

   per2.changeName("YS")     // 可以修改
   fmt.Println(per2)
}

总结:

8、非结构体上绑定方法

不允许在基础数据类型上绑定方法(如:intstring ... )

但是自己定义的类型可以绑定方法


type Myint int

func (i *Myint) add() {
   (*i)++
}

func main() {
   var a Myint = 10
   fmt.Println(a) // 输出:10
   a.add()
   a.add()
   a.add()
   fmt.Println(a) // 输出:13
}

到此这篇关于Go语言之结构体与方法的文章就介绍到这了,更多相关Go语言之结构体内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网!

阅读原文内容投诉

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机
位置:首页-资讯-后端开发
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯