AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Go 语言 结构体和方法

2022-04-27 158
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 1. 结构体别名定义2. 工厂模式3. Tag 原信息4. 匿名字段5. 方法

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
数据格式
JSON
关键词：
Go语言
Go方法
Go结构体
Go结构体方法
Go语言结构体方法
隐姓埋名4869
目录
相关文章
凉凉心.
|
11天前
|
存储 安全 Java
【Golang】（4）Go里面的指针如何？函数与方法怎么不一样？带你了解Go不同于其他高级语言的语法
结构体可以存储一组不同类型的数据，是一种符合类型。Go抛弃了类与继承，同时也抛弃了构造方法，刻意弱化了面向对象的功能，Go并非是一个传统OOP的语言，但是Go依旧有着OOP的影子，通过结构体和方法也可以模拟出一个类。
凉凉心.
62 1
跃@sir
|
2月前
|
Cloud Native 安全 Java
Go：为云原生而生的高效语言
Go：为云原生而生的高效语言
跃@sir
249 1
跃@sir
|
2月前
|
Cloud Native Go API
Go：为云原生而生的高效语言
Go：为云原生而生的高效语言
跃@sir
286 0
跃@sir
|
2月前
|
Cloud Native Java Go
Go：为云原生而生的高效语言
Go：为云原生而生的高效语言
跃@sir
200 0
跃@sir
|
2月前
|
Cloud Native Java 中间件
Go：为云原生而生的高效语言
Go：为云原生而生的高效语言
跃@sir
166 0
跃@sir
|
2月前
|
Cloud Native Java Go
Go：为云原生而生的高效语言
Go：为云原生而生的高效语言
跃@sir
257 0
程序员爱钓鱼
|
2月前
|
数据采集 Go API
Go语言实战案例:多协程并发下载网页内容
本文是《Go语言100个实战案例 · 网络与并发篇》第6篇，讲解如何使用 Goroutine 和 Channel 实现多协程并发抓取网页内容，提升网络请求效率。通过实战掌握高并发编程技巧，构建爬虫、内容聚合器等工具，涵盖 WaitGroup、超时控制、错误处理等核心知识点。
程序员爱钓鱼
125 0
程序员爱钓鱼
|
2月前
|
数据采集 JSON Go
Go语言实战案例：实现HTTP客户端请求并解析响应
本文是 Go 网络与并发实战系列的第 2 篇，详细介绍如何使用 Go 构建 HTTP 客户端，涵盖请求发送、响应解析、错误处理、Header 与 Body 提取等流程，并通过实战代码演示如何并发请求多个 URL，适合希望掌握 Go 网络编程基础的开发者。
程序员爱钓鱼
403 0
程序员爱钓鱼
|
3月前
|
JSON 前端开发 Go
Go语言实战：创建一个简单的 HTTP 服务器
本篇是《Go语言101实战》系列之一，讲解如何使用Go构建基础HTTP服务器。涵盖Go语言并发优势、HTTP服务搭建、路由处理、日志记录及测试方法，助你掌握高性能Web服务开发核心技能。
程序员爱钓鱼
287 0
蓝易云
|
3月前
|
Go
如何在Go语言的HTTP请求中设置使用代理服务器
当使用特定的代理时，在某些情况下可能需要认证信息，认证信息可以在代理URL中提供，格式通常是：
蓝易云
298 0

热门文章

最新文章

  • 1
    Go语言深度解析：从入门到精通的完整指南
  • 2
    Go语言100个实战案例-进阶与部署篇：使用Go打包生成可执行文件
  • 3
    Go语言深度解析：从入门到精通的完整指南
  • 4
    Go语言实战案例-项目实战篇：编写一个轻量级在线聊天室
  • 5
    Go 微服务限流与熔断最佳实践：滑动窗口、令牌桶与自适应阈值
  • 6
    Github 12.3kstar, 3分钟起步做中后台？Go+Vue 脚手架，把权限、代码生成、RBAC 都封装好了
  • 7
    企业电脑监控系统中基于 Go 语言的跳表结构设备数据索引算法研究
  • 8
    对比Java学习Go——函数、集合和OOP
  • 9
    【GoGin】（0）基于Go的WEB开发框架，GO Gin是什么？怎么启动？本文给你答案
  • 10
    【GoGin】（1）上手Go Gin 基于Go语言开发的Web框架，本文介绍了各种路由的配置信息；包含各场景下请求参数的基本传入接收
  • 1
    【字节跳动青训营】后端笔记整理-2 | Go实践记录：猜谜游戏，在线词典，Socks5代理服务器
    232
  • 2
    【字节跳动青训营】后端笔记整理-1 | Go语言入门指南：基础语法和常用特性解析（三）
    215
  • 3
    Go 语言常量
    73
  • 4
    Go 语言变量
    83
  • 5
    Go 语言数据类型
    97
  • 6
    使用go的内置运行时库调试和优化程序
    125
  • 7
    Go 语言基础语法
    126
  • 8
    Go 语言结构
    49
  • 9
    Go 语言环境安装
    112
  • 10
    GO语言中的runtime功能概要
    201

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法
  • Go语言核心编程 - 基础语法、数组、切片、Map
  • Go语言核心编程 - 面向对象、文件、单元测试、反射、TCP编程
  • Go语言完全自学手册图文教程

    • 相关电子书

    更多
  • Go语言路上踩过的坑
  • gohbase ：HBase go客户端
  • Go构建日请求千亿级微服务实践
    • 下一篇
    阿里云无影云电脑免费使用_免费申请教程