Go学习(十二):面向对象-结构体(struct)

已于 2023-02-02 14:00:36 修改
阅读量323 收藏
点赞数
分类专栏： Go基础篇 文章标签： 后端 golang
于 2023-02-02 13:53:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39001207/article/details/128849029
版权

Go没有沿袭传统面向对象编程中的诸多概念，也没有提供类(class)，但是它提供了结构体(struct)，方法(method)可以在结构体上添加。与类相似，结构体提供了捆绑数据和方法的行为。

1. 介绍

1.1 概念

单一的数据类型已经满足不了现实开发需求，于是 Go 语言提供了结构体来定义复杂的数据类型。结构体是由一系列相同类型或不同类型的数据构成的数据集合。结构体的定义只是一种内存布局的描述，只有当结构体实例化时，才会真正地分配内存。因此必须在定义结构体并实例化后才能使用结构体的字段。

1.2 语法
type 类型名称 struct {
   field type
   field type 
   field1,field2,field3 type // 同类型变量可以写在一行
}
1.3 注意事项
  • 类型名是标识结构体的名称，在同一个包内不能重复。
  • 结构体的属性，也叫字段(field)，必须唯一。
  • 同类型的成员属性可以写在一行。
  • 结构体是值类型。
  • 只有当结构体实例化时,才能使用结构体的字段。

2. 实例化

2.1 使用var
package main
import "fmt"
// 定义结构体
type student struct {
	name string
	age int
	like []string
}
func main() {
	// 使用var 实例化结构体
	var s student
	fmt.Printf("变量s--> 类型: %T 值: %v \n",s,s)
	// 给属性赋值
	s.name = "张三"
	s.age = 20
	s.like = []string{"打游戏","看动漫"}
	fmt.Printf("给属性赋值: 变量s--> 类型: %T 值: %v \n",s,s)
}
/*输出
变量s--> 类型: main.student 值: { 0 []} 
给属性赋值: 变量s--> 类型: main.student 值: {张三 20 [打游戏 看动漫]} 
*/
3.2 使用简短声明 (:=)
package main
import "fmt"
// 定义结构体
type student struct {
	name string
	age int
	like []string
}
func main() {
	// 方式一: 先实例化结构体，后赋值
	s := student{}
	// 给属性赋值
	s.name = "张三"
	s.age = 20
	s.like = []string{"打游戏","看动漫"}
	fmt.Printf(" 变量s--> 类型: %T 值: %v \n",s,s)

	// 方式二: 声明时初始化
	s1 := student{
		name: "李四",
		age:  23,
		like: []string{"旅游","运动"},
	}
	fmt.Printf(" 变量s1--> 类型: %T 值: %v \n",s1,s1)

	// 方式三: 声明时初始化，省略属性
	s2 := student{"王麻子",30,[]string{"睡觉","吃饭"}}
	fmt.Printf(" 变量s2--> 类型: %T 值: %v \n",s2,s2)
}
/**输出
 变量s--> 类型: main.student 值: {张三 20 [打游戏 看动漫]} 
 变量s1--> 类型: main.student 值: {李四 23 [旅游 运动]} 
 变量s2--> 类型: main.student 值: {王麻子 30 [睡觉 吃饭]} 
*/
3.3 使用new

使用内置函数new()对结构体进行实例化，结构体实例化后形成指针类型的结构体，new()内置函数会分配内存。第一个参数是类型，而不是值，返回的值是指向该类型新分配的零值的指针。

package main
import "fmt"
// 定义结构体
type student struct {
	name string
	age int
	like []string
}
func main() {
	// 使用new实例化
	s := new(student)
	fmt.Printf(" 变量s--> 类型: %T 值: %v \n",s,s)
	// 给属性赋值
	(*s).name = "包青天"
	(*s).age = 55
	(*s).like = []string{"判案"}
	fmt.Printf(" 变量s--> 类型: %T 值: %v \n",s,s)
	// 语法糖写法(省略*)
	s.name = "包大人"
	s.age = 99
	s.like = []string{"判案","元芳你怎么看"}
	fmt.Printf(" 变量s--> 类型: %T 值: %v \n",s,s)
}
/**输出
 变量s--> 类型: *main.student 值: &{ 0 []} 
 变量s--> 类型: *main.student 值: &{包青天 55 [判案]} 
 变量s--> 类型: *main.student 值: &{包大人 99 [判案 元芳你怎么看]} 
*/

3. 结构体在函数中使用

结构体作为函数参数，若复制一份传递到函数中，在函数中对参数进行修改，不会影响到实际参数，证明结构体是值类型。

3.1 传结构体值作为参数
package main
import "fmt"
// 定义结构体
type student struct {
	name string
	age int
	like []string
}
func main() {
	s := student{name:"张三",age:17}
	fmt.Printf(" 变量s--> 值: %v \n",s)
	grownUp(s)
	fmt.Printf("调用函数后,变量s--> 值: %v \n",s)
}
// 传结构体值作为参数
func grownUp( s student)  {
	s.age = 80
	s.name = "长大的 "+s.name
}
/**输出
 变量s--> 值: {张三 17 []} 
 调用函数后,变量s--> 值: {张三 17 []} 
*/
3.2 传结构体指针作为参数
package main
import "fmt"
// 定义结构体
type student struct {
	name string
	age int
	like []string
}
func main() {
	s := student{name:"张三",age:17}
	fmt.Printf(" 变量s--> 值: %v \n",s)
  // 取址
	grownUp(&s)
	fmt.Printf("调用函数后,变量s--> 值: %v \n",s)
}
// 传结构体指针作为参数
func grownUp( s *student)  {
	s.age = 80
	s.name = "长大的 "+s.name
}
/** 输出:
 变量s--> 值: {张三 17 []} 
 调用函数后,变量s--> 值: {长大的 张三 80 []} 
*/
3.3 返回对象
package main
import "fmt"
// 定义结构体
type student struct {
	name string
	age int
	like []string
}
func main() {
	s := getStudent("杨过",40,[]string{"骑大雕"})
	fmt.Printf("函数返回值 s--> 值: %v  类型: %T \n",s,s)
}
// 作为值类型传递
func getStudent( name string, age int,likes []string) student  {
	return student{name,age,likes}
}
// 函数返回值 s--> 值: {杨过 40 [骑大雕]}  类型: main.student
3.4 返回指针
package main
import "fmt"
// 定义结构体
type student struct {
	name string
	age int
	like []string
}
func main() {
	s := getStudent("杨过",40,[]string{"骑大雕"})
	fmt.Printf("函数返回值 s--> 值: %v  类型: %T \n",s,s)
}

// 返回指针
func getStudent( name string, age int,likes []string) *student  {
	return &student{name,age,likes}
}
// 输出: 函数返回值 s--> 值: &{杨过 40 [骑大雕]}  类型: *main.student

4.匿名结构体

4.1 语法
变量名 := struct {
  // 定义成员属性
} { /*初始化成员属性*/ }
4.2 使用
package main
import "fmt"
func main() {
	// 声明初始化匿名结构体
	s := struct {
		name, home, phone string
		age               int
	}{
		name:  "张二十",
		phone: "17600111111",
		age:   18,
	}
  // 打印
	fmt.Printf("变量 s--> 值: %v  类型: %T \n", s, s)
}
// 输出: 变量 s--> 值: {张二十  17600111111 18}  类型: struct { name string; home string; phone string; age int }

5.匿名字段

5.1 定义

匿名字段就是在结构体中的字段没有名字，只包含一个没有字段名的类型。这些字段被称为匿名字段。在同一个结构体中,同一个类型只能有一个匿名字段。

5.2 使用
package main
import "fmt"
type people struct {
	name, home string
	int        // 匿名字段
	float32    // 匿名字段
}
func main() {
	// 声明初始化匿名结构体
	s := people{name: "张三", home: "北京", int: 18, float32: 1.73}
	fmt.Printf("变量 s--> 值: %v \n", s)
	// 声明初始化匿名结构体(省略属性名)
	s2 := people{"李四", "南京", 22, 1.80}
	fmt.Printf("变量 s2--> 值: %v \n", s2)
}
/** 输出
  变量 s--> 值: {张三 北京 18 1.73} 
  变量 s2--> 值: {李四 南京 22 1.8} 
*/

6. 结构体嵌套

6.1 定义

将一个结构体作为另一个结构体的属性（字段），这种结构就是结构体嵌套。

结构体嵌套可以模拟面向对象编程中的以下两种关系。

  • 聚合关系: 一个类作为另一个类的属性。
  • 继承关系: 一个类作为另一个类的子类。子类和父类的关系。
6.2 聚合场景

模拟聚合关系时一定要采用有名字的结构体作为字段。

package main
import "fmt"
// 定义学生结构体
type student struct {
	name       string
	height      float32
	schoolInfo  school
}
// 定义学习结构体
type school struct {
	schoolName, schoolAddress string
}
func main() {
	// 简短声明嵌套结构体
	s := student{"小张",1.72,school{"北京大学","北京"}}
	fmt.Printf("变量 s--> 值: %v 类型: %T \n", s,s)
	// 使用var
	var ss student
	ss.name = "小龙"
	ss.height = 1.67
	ss.schoolInfo = school{"南京大学","南京"}
	fmt.Printf("变量 ss--> 值: %v 类型: %T \n", ss,ss)
	// 使用new
	s2 := new(student)
	s2.name = "小虎"
	s2.height = 1.77
	s2.schoolInfo.schoolName = "武汉大学"
	s2.schoolInfo.schoolAddress = "武汉"
	fmt.Printf("变量 s2--> 值: %v 类型: %T \n", s2,s2)
}
/** 输出:
  变量 s--> 值: {小张 1.72 {北京大学 北京}} 类型: main.student 
  变量 ss--> 值: {小龙 1.67 {南京大学 南京}} 类型: main.student 
  变量 ss--> 值: &{小虎 1.77 {武汉大学 武汉}} 类型: *main.student 
*/
6.3 模拟继承

在结构体中，属于匿名结构体的字段称为提升字段，它们可以被访问，匿名结构体就像是该结构体的父类。

package main
import "fmt"

// 定义父类结构体
type people struct {
	name  string
	age   int
}
type student struct {
	people // 集成父类结构体
	class string
}

func main() {
	// 方式1.使用new声明结构体
	var s = new(student)
	// 集成父类成员
	s.name = "张三"
	s.age = 12
	// 自己成员
	s.class = "三年级"
	fmt.Printf("变量s -> %v \n",s)
	// 方式2.使用简短声明
	s2 := student{people{"李四",13},"四年级"}
	fmt.Printf("变量s2 -> %v \n",s2)
}
/** 输出
变量s -> &{{张三 12} 三年级} 
变量s2 -> {{李四 13} 四年级} 
*/
6.4 成员冲突
package main
import "fmt"
type A struct {
	name string
	age  int
}
type B struct {
	name   string
	height float32
}
// 在C结构体中嵌套A和B
type C struct {
	A
	B
}
func main() {
	// 定义结构体C
	c := C{}
	// 不冲突的成员赋值
	c.age = 12
	c.height = 1.88
	// 冲突的成员赋值
	c.A.name = "这是A的成员"
	c.B.name = "这是B的成员"
	fmt.Printf("变量c -> %v \n", c)
}
// 输出: 变量c -> {{这是A的成员 12} {这是B的成员 1.88}}

本文由mdnice多平台发布

猿码记
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
go代码-Go 接口+结构体-面向对象demo
07-16
在Go语言中，接口（Interface）和结构体（Struct）是实现面向对象编程的重要概念。本文将深入探讨这两个概念，并通过一个具体的“Go接口+结构体-面向对象”示例来帮助理解它们如何协同工作。 首先，让我们了解什么...
浅谈Go语言中的结构体struct & 接口Interface & 反射
09-21
在Go语言中，结构体（`struct`）是用来创建自定义数据类型的工具，它允许我们将多个不同的数据类型组合成一个整体。结构体可以包含多个字段（属性），这些字段可以是基本类型，也可以是其他结构体或者接口。在Go中，...
C语言面向对象编程结-构体实现面向对象编程
LC的专栏
03-30 3711
结构体是一个非常重要的知识点，必须掌握和深入理解使用。现在网络上还经常讨论函数式编程和面向对象编程。很多人认为，C语言编程，就是函数式编程，C++, JAVA等高级语言，才是面向对象编程。 其实，这是错误的认识！面向对象编程是一种思想，是一种编程思路，实现这种编程思路，不局限于是使用C语言还是使用C++语言。 使用C语言也可以实现面向对象编程。例如li...
go-结构体与面向对象 3
weixin_44102152的博客
05-14 237
一、go结构体 结构体的定义 指针与结构体 初始化结构体 类型别名和自定义类型 二、go面向对象-结构体与接口 构造函数 方法 方法与指针 嵌套结构体下《继承》 方法规则 接口
Go第 10 章 ：面向对象编程(上)
tianyi520jx的博客
01-06 536
在某些情况下，我们要需要声明(定义)方法。比如 Person 结构体:除了有一些字段外( 年龄，姓名…),Person 结构体还有一些行为比如:可以说话、跑步…,通过学习，还可以做算术题。这时就要用方法 才能完成。Golang 中的方法是作用在指定的数据类型上的(即：和指定的数据类型绑定)，因此自定义类型， 都可以有方法，而不仅仅是 struct。func (recevier type) methodName（参数列表） (返回值列表){方法体return 返回值参数列表：表示方法输入。
Go语言实践[回顾]教程27--详解Go语言结构体 struct 定义与面向对象编程思想
IT技术实战
10-24 767
在 Go 语言中没有其他常用语言中“类”的概念，那么面向对象编程的理念是不是就无法在 Go 语言中应用呢？答案是可以，虽然没有“类”，但是取而代之的是“结构体 struct”。Go 语言依据强大的类型系统，使用结构体可以构建各种新的数据类型，再配以其方法，就可以灵活实现各种对象所需的基础定义。这种方式简单干净，没有为了实现继承和多态而额外添加虚拟函数指针，尽量减少相互关联，多态则由接口来实现，具有简单、平坦、直接、易懂、易记等鲜明特点。
Go语言基础之结构体
tianyi19的博客
01-14 539
Go语言基础之结构体 前言 Hey，大家好呀，我是星期八，终于迎来了Go中最大一个知识点，结构体。 在Go，是没有类和对象这个概念的。 是通过结构体的各种操作，模拟出来的像Java，Python之类的面向对象的。 回忆map 之前我们讲过，Go语言的map是键值对的方式存储数据的，就像这样的。 //方式一 var student = map[string]string{ "Name": "张三"， "Age": "18"， } //方式二 var student2 = make(map[s
go代码-结构体的简单使用 传参 指针
07-14
综上所述，Go语言中的结构体和指针是实现面向对象编程的关键工具。理解它们的用法对于编写高效、清晰的Go代码至关重要。在实际开发中，根据场景选择合适的接收者类型，以确保代码的效率和可维护性。
C++类和对象，结构体
TX98337的博客
09-15 4503
趁着中秋放假要多补补知识了，感觉自己对C++了解的不够扎实，，为了更好的工作，只好再来看看。      C和C++规定可以用一个结构体，里面即可有数组，也可以有其他变量。C中成员只能是数据，C++除了数据，还可以是函数。   但是，C++提供了类这个东西，所以不需要包含函数的结构体。 1，结构体： #include using namespace std; int main(){  
简单的C语言结构体实现面向对象的方法
hhl3065212的博客
09-27 2896
一种简单方法，C语言实现面向对象类的方法。
Golang 奇葩的时间包之Json与struct对象之间互相转换，JsonDate和JsonTime自定义类型如何实现json编码和解码（二）
zhengzizhi的专栏
06-25 5548
JsonDate和JsonTime自定义类型如何实现json编码和解码
C语言结构体对象间直接赋值
热门推荐
欢迎光临
08-03 1万+
C语言中变量间互相赋值很常见，例如：int a,b; a = b;结构体也是变量（自定义变量），两个结构体之间直接赋值按道理应该也是可以的吧，说实话之前还从没遇到过将一个结构体对象赋值给另一个结构体对象的（见识太浅），那么下面做一个测试看看：#include "stdio.h"struct test { int a; int b; int c; char *d; };
结构体作为对象的属性
sock的博客
05-28 320
typedef struct { int year; int month; int day; } Date;@interface Student : NSObject { @public NSString *_name; Date _birthday; }- (void)say;@end @implementation Student- (void)s
【Go】 结构体形式的面向对象
风景旧曾谙
06-12 168
对象，是一个永恒的话题 —— 开发实习生 面向对象 Go 里面的面向对象，没有继承，没有多态这些花里胡哨的东西，它就一个封装。 结构体 func main() { var root TreeNode root = TreeNode{value: 0} root.left = &TreeNode{} root.right = &TreeNode{nil , nil , 1} root.right.left = new(TreeNode) fmt.Println(root) }
结构体
像风一样自由
09-08 777
什么是结构体？同一种类型的数据集合是数组，结构体是多种数据的集合。结构体的数据类型声明//结构体的声明方式1 // stu 称为结构名 // struct stu 称为类型名 struct stu { char name[10]; int age;//结构体成员 };结构体对象的使用struct stu s; //相当于 java中的 new stu成员初始化,与数组赋初值的
go语言-面向对象之结构体与方法(十)
xiangjai的专栏
07-15 235
go语言仅支持封装，不支持继承和多态type node struct { value int left *node right *node } var root node root = node{value:1} //root := node{value:1} root.left = &node{value:2} root.left.right = &node{va...
使用struct实现面向对象编程的封装
weixin_30419799的博客
10-25 122
虽然C是面向过程的语言,但是这不代表C不能使用面向对象的思想,本质上说语言只是一种手段而已,一种外在的表现形式,支持面向对象的语言只是通过设计的特定的关键字更好的表现了面向对象编程而已.C中也可以使用面向对象的思想,通过struct结构体和函数指针来实现. struct表示java或C#中的类Class,struct中的字段表示类中的属性,函数指针表示类中的方法.简单的实现代码如下: #inclu...
go语言学习思维导图
最新发布
01-11
很高兴为您介绍Go语言学习思维导图。根据提供的引用内容，Go语言学习思维导图...通过学习这些内容，您将对Go语言的基础知识、数据类型、流程控制、函数、复合数据类型、面向对象、泛型、并发和反射有一个全面的了解。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值