Go语言学习之结构体和方法使用详解

更新时间：2022年04月21日 08:18:06 作者：隐姓埋名4869

这篇文章主要为大家详细介绍了Go语言中结构体和方法的使用，文中的示例代码讲解详细，对我们学习Go语言有一定的帮助，需要的可以参考一下

1. 结构体别名定义

变量别名定义

package main

import "fmt"

type integer int

func main() {
	//类型别名定义
	var i integer = 1000
	fmt.Printf("值: %d, 类型: %T\n", i, i)

	var j int = 100
	j = int(i) 			//j和i不属于同一类型，需要转换
	fmt.Println(j)
}

输出结果如下

值: 1000, 类型: main.integer
1000

结构体别名定义

package main

import "fmt"

//创建结构体Student
type Student struct {
	Number int
}

//结构体定义别名
type Stu Student

func main() {
	//声明Student类型结构体
	var a Student
	a = Student{30}

	//声明Stu类型结构体
	var b Stu
	b = Stu{20}

	//强转类型后才能进行赋值
	a = Student(b)
	fmt.Printf("a = %d,类型: %T\n", a, a)
	b = Stu(a)
	fmt.Printf("b = %d,类型: %T\n", b, b)
}

输出结果如下

a = {20},类型: main.Student
b = {20},类型: main.Stu

2. 工厂模式

Go 中所谓的工厂模式其实就是：

包内一个不可直接实例的结构体（结构体名称首字母小写），包外不可直接实例，那么为了解决这个问题，就写一个包外可调用的函数，通过这个函数实现返回结构体对象。

package main

import "fmt"

type Student struct {
	Name string
	Age  int
}

func main() {
	//初始化
	stu1 := new(Student)
	fmt.Println(stu1)

	//工厂模式处理
	stu2 := NewStudent("张三", 18)
	fmt.Println(stu2)
}

//工厂模式
func NewStudent(name string, age int) *Student {
	return &Student{
		Name: name,
		Age:  age,
	}
}

输出结果如下

&{ 0}
&{张三 18}

总结:① make 用来创建map、slice、channel

② new 用来创建值类型

3. Tag 原信息

在和其他语言进行对接交互时使用JSON格式，有些语言格式大小写规范比较严格，为了使Go语言和其他语言对接数据传输，所以使用Tag原信息进行解决

通俗的来说就相当于是一个充电的转接口

示例

package main

import (
	"encoding/json"
	"fmt"
)

type Student struct {
	Name  string
	Age   int
	Score float32
}

func main() {
	//初始化
	var stu = new(Student)
	stu.Name = "stu"
	stu.Age = 20
	stu.Score = 88

	//使用Json处理结构体，转换成字节数组
	data, err := json.Marshal(stu)
	if err != nil {
		fmt.Println("错误提示:", err)
		return
	}
	fmt.Println(data)				//字节数组形式输出
	fmt.Println(string(data))		//转换成字符串输出
}

输出结果如下

[123 34 78 97 109 101 34 58 34 115 116 117 34 44 34 65 103 101 34 58 50 48 44 34 83 99 111 114 101 34 58 56 56 125]
{"Name":"stu","Age":20,"Score":88}

JSON格式化字段名

package main

import (
	"encoding/json"
	"fmt"
)

type Student struct {
	//json打包时字段名
	Name  string  `json:"stu_name"`
	Age   int     `json:"stu_age"`
	Score float32 `json:"stu_score"`
}

func main() {
	//初始化
	var stu = new(Student)
	stu.Name = "stu"
	stu.Age = 20
	stu.Score = 88

	//使用Json处理结构体，转换成字节数组
	data, err := json.Marshal(stu)
	if err != nil {
		fmt.Println("错误提示:", err)
		return
	}
	fmt.Println(data)
	fmt.Println(string(data))
}

输出结果如下

[123 34 115 116 117 95 110 97 109 101 34 58 34 115 116 117 34 44 34 115 116 117 95 97 103 101 34 58 50 48 44 34 115 116 117 95 115 99 111 114 101 34 58 56 56 125]
{"stu_name":"stu","stu_age":20,"stu_score":88}

4. 匿名字段

结构体中的字段（属性）没有名称，称之为匿名字段

示例

package main

import "fmt"

type Cart struct {
	name  string
	color string
}

type Train struct {
	//匿名字段
	Cart //实现继承
	int  //数据类型定义，仅能存在一次，两个int则会冲突
}

func main() {
	//初始化赋值
	var t Train		
	t.name = "train"
	t.color = "red"
	t.int = 10		//直接调用数据类型赋值
	fmt.Println(t)
}

输出结果如下

{{train red} 10}

双引用结构体，多继承（继承的两个结构体中定义相同属性）

package main

import "fmt"

//父结构体
type Cart struct {
	name  string
	color string
}

//父结构体
type Box struct {
	color string
}

//子结构体
type Train struct {
	//匿名字段
	Cart //实现继承
	Box
	int //数据类型定义，仅能存在一次，两个int则会冲突
}

func main() {
	//初始化赋值
	var t Train
	t.name = "train"
	t.Cart.color = "red"
	t.Box.color = "blue"
	t.int = 10 //直接调用数据类型赋值
	fmt.Println(t)
}

输出结果如下

{{train red} {blue} 10}

package main

import "fmt"

//父结构体
type Cart struct {
	name  string
	color string
}

//父结构体
type Box struct {
	color string
}

//子结构体
type Train struct {
	//匿名字段
	Cart //实现继承
	Box
	int   //数据类型定义，仅能存在一次，两个int则会冲突
	color string
}

func main() {
	//初始化赋值
	var t Train
	t.name = "train"
	t.Cart.color = "red" //Cart的属性
	t.Box.color = "blue" //Box的属性
	t.color = "yellow"   //train自身属性
	t.int = 10           //直接调用数据类型赋值
	fmt.Println(t)
}

5. 方法

Go 中的方法是作用在特定类型的变量上，因此自定义类型，都可以有方法，而不仅仅是 struct
语法格式如下

func (recevier type) methodName(参数列表)(返回值){}

recevier type     特定类型，如指针、别名，结构体 
methodName           方法名

示例

package main

import "fmt"

//定义结构体
type Student struct {
	Name string
	Age  int
}

//定义方法
func (s Student) init(name string, age int) Student {
	s.Name = name
	s.Age = age
	return s
}

func main() {
	var stu Student
	s := stu.init("zhangsan", 18)
	fmt.Printf("s: %v\n", s)
}

输出结果

s: {zhangsan 18}

定义返回方法是否会把初始化的值给返回？

package main

import "fmt"

//定义结构体
type Student struct {
	Name  string
	Age   int
	Score float32
}

//初始化方法
func (s *Student) init(name string, age int, score float32) {
	s.Name = name
	s.Age = age
	s.Score = score
	fmt.Println("初始化完成")
}

//返回结构体
func (s *Student) get() Student {
	return *s
}

func main() {
	var stu Student
	//定义值
	stu.init("zhangsan", 18, 90)
	//返回值
	stu1 := stu.get()
	fmt.Println(stu1)
}

输出结果如下

初始化完成
{zhangsan 18 90}

传统数据类型自定义方法，做数据类型转换

package main

import "fmt"

//别名类型
type integer int

//传统数据类型自定义方法
func (p integer) convert() string {
	return fmt.Sprintf("%d", p)
}

func main() {
	var i integer
	i = 100
	s := i.convert()
	fmt.Printf("类型:%T,值:%s\n", s, s)
}

输出结果如下

类型:string,值:100

指针传入和值传入的区别

值传入不会对数值进行改变，指针传入才可以改变数值

package main

import "fmt"

type integer int

//传统数据类型自定义方法
func (p integer) convert() string {
	return fmt.Sprintf("%d", p)
}

//方法传指针进行数据同步修改
func (p *integer) set(b integer) {
	*p = b
}

func main() {
	var i integer
	i = 100
	s := i.convert()
	fmt.Printf("类型: %T ,值: %s\n", s, s)
	fmt.Printf("类型: %T ,值: %d\n", i, i)
	i.set(200)
	fmt.Printf("i: %v\n", i)
}

输出结果如下

类型: string ,值: 100
类型: main.integer ,值: 100
i: 200

方法继承，组合（匿名字段是组合的特殊形式）

package main

import "fmt"

//父结构体
type Car struct {
	weight int
	name   string
}

//父方法
func (c *Car) Run() {
	fmt.Println("Running")
}

//子结构体Bike
type Bike struct {
	//组合(有名字)
	c     Car
	wheel int
}

//子结构体Train
type Train struct {
	//匿名
	Car
	wheel int
}

func main() {
	var bike Bike
	bike.c.name = "bike"
	bike.c.weight = 500
	bike.wheel = 2

	var train Train
	train.name = "train"
	train.weight = 140000
	train.wheel = 8

	fmt.Println(bike)
	//方法继承,调用父结构体方法
	bike.c.Run()

	fmt.Println(train)
	//方法继承
	train.Run()
}

输出结果如下

{{500 bike} 2}
Running
{{140000 train} 8}
Running

package main

import "fmt"

//父结构体
type Cart struct {
	weight int
	Color  string
}

//父方法
func (c Cart) Run() {
	fmt.Println("Running")
}

//子结构体train
type Train struct {
	Cart
	wheel int
}

//子结构体方法
func (t Train) String() string {
	str := fmt.Sprintf("color:[%s],weight:[%d],wheel:[%d]\n", t.Color, t.weight, t.wheel)
	return str
}

func main() {
	var train Train
	train.Color = "red"
	train.weight = 14000
	train.wheel = 8
	fmt.Println(train)
	train.Run()
	fmt.Printf("%s\n", train)
}

输出结果如下

color:[red],weight:[14000],wheel:[8]

Running
color:[red],weight:[14000],wheel:[8]

到此这篇关于Go语言学习之结构体和方法使用详解的文章就介绍到这了,更多相关Go语言结构体方法内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

golang如何操作csv文件详解
这篇文章主要给大家介绍了关于golang如何操作csv文件的相关资料,以及使用Golang导出CSV数据并解决数据乱码问题的解决办法,文中通过示例代码介绍的非常详细,需要的朋友可以参考下
2022-02-02
golang实现微信支付v3版本的方法
这篇文章主要介绍了golang实现微信支付v3版本的方法,本文给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
2021-03-03
Golang分布式锁简单案例实现流程
分布式锁是控制分布式系统之间同步访问共享资源的一种方式。如果不同的系统或是同一个系统的不同主机之间共享了一个或一组资源，那么访问这些资源时，需要通过一些互斥手段来防止彼此之间的干扰以保证一致性，在这种情况下，就需要使用分布式锁了
2022-12-12
Go语言基础数组用法及示例详解
这篇文章主要为大家介绍了Go语言基础Go语言数组的用法及示例详解，有需要的朋友可以借鉴参考下，希望能够有所帮助，祝大家多多进步，早日升职加薪
2021-11-11
在Go语言中实现DDD领域驱动设计实例探究
本文将详细探讨在Go项目中实现DDD的核心概念、实践方法和实例代码,包括定义领域模型、创建仓库、实现服务层和应用层,旨在提供一份全面的Go DDD实施指南
2024-01-01
golang使用sync.singleflight解决热点缓存穿透问题
在go的sync包中，有一个singleflight包，里面有一个 singleflight.go文件，代码加注释，一共200行出头，通过 singleflight可以很容易实现缓存和去重的效果，避免重复计算，接下来我们就给大家详细介绍一下sync.singleflight如何解决热点缓存穿透问题
2023-07-07
Go语言中实现Unix风格的进程管道方法实例
这篇文章主要为大家介绍了Go语言中实现Unix风格的进程管道方法实例,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
2023-12-12
GO中分组声明与array, slice, map函数
这篇文章主要介绍了GO中分组声明与array,slice,map函数，Go语言中，同时声明多个常量、变量，或者导入多个包时，可采用分组的方式进行声明，下面详细介绍需要的小伙伴可以参考一下
2022-03-03
go语言错误处理基本概念(创建返回)
这篇文章主要为大家介绍了go语言错误处理基本概念(创建返回),有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪
2023-08-08
深入解析golang中的标准库flag
Go语言内置的flag包实现了命令行参数的解析，flag包使得开发命令行工具更为简单，下面通过本文给大家详细介绍下golang中的标准库flag相关知识，感兴趣的朋友一起看看吧
2021-11-11